10 AWS CFP Ideas for 2025 + How to Write Your Own with PartyRock and Amazon Q
Need AWS conference proposal ideas for 2025? Brooke Jamieson provides 10 ready-to-use templates and shows how to create more using Amazon Q Developer and PartyRock.
Brooke Jamieson
Amazon Employee
Published Jan 30, 2025
Foundation Topics: Getting Started with AWS Services
Idea 1 | DynamoDB Fundamentals: A Practical Guide to Getting Started Right
Idea 2 | S3 Lifecycle Management: From Basics to Best Practices
Idea 3 | EC2, Containers, or Serverless? A Practical Guide to AWS Computing Choices
Idea 4 | Untangling Your VPC: A Step-by-Step Cleanup Guide
Idea 5 | From Chaos to Control: A Practical Guide to AWS IAM Cleanup
Idea 6 | Measuring What Matters: Essential Lambda Performance Metrics
Idea 7 | Practical Steps to Control and Optimize AWS Spending
Idea 8 | When Events Go Wrong: A Practical Guide to AWS Debugging
Idea 9 | Production SageMaker: What I Wish I Knew When Starting
Idea 10 | Amazon Bedrock: Essential Patterns for Production Success
Step 2 | Ask Amazon Q Developer for the answers in your IDE
Step 3 | Build the PartyRock App
After speaking at about 50 conferences/events, I've noticed something fundamentally broken about the Call for Proposals (CFP) process. We expect speakers to be mind readers - guessing what conferences want, creating proposals from scratch, and formatting them in specific ways that nobody teaches. Meanwhile, conference organizers piece together schedules from random submissions, often missing crucial topics they wanted to cover while getting flooded with proposals on topics they don't need.
What if we flipped this? Instead of making speakers guess what organizers want, what if conferences provided a list of desired talks and asked speakers to explain why they're the right person to present them? This approach would:
- Welcome new speakers by removing the barrier of learning to to write CFPs before getting a chance to speak
- Help qualified speakers find opportunities to share their expertise
- Enable organizers to build more balanced, purposeful conference schedules
To help bridge this gap, I've built a PartyRock app that helps you to generate structured, technically-sound CFP ideas. This post shares ten ready-to-adapt proposals for 2025 AWS events made with my app, plus a technical walkthrough of how I created them using PartyRock and Amazon Q Developer. You can use these proposals as inspiration, or try the app yourself to generate ideas that match your expertise.
If you're planning to speak at or organize tech events in 2025, you'll find practical templates and tools here to help you succeed.
And if you're a technical leader or mentor who knows someone with valuable experience to share, consider forwarding this article - it might be just the encouragement they need to take their first step into speaking!
In this post:
Before we dive in to the CFP ideas, here’s some quick tips for using them effectively:
- Make it your own: These proposals are starting points - your personal experiences are what make your talk valuable to the community.
- Pick topics you’re confident discussing: Getting accepted by an event means committing to research, preparation, rehearsal, and delivering high-quality content, so make sure it’s something you’re genuinely passionate about and have hands-on experience with.
- Focus on quality not quantity: Don’t “spray and pray” and send in heaps of submissions - limit yourself to 1-2 per event. Overloading organizers makes their job harder, and it can damage your reputation.
- Want to learn more about what it’s like finding and applying to speak at events? Let me know in the comments, and I can make a follow up post answering lots of FAQs!
I built a PartyRock app to generate CFP ideas based on questions junior developers might ask their senior teammates. This is my go-to strategy for coming up with AWS User Group talk ideas because it means the content will be accessible for beginners in the audience, and still relevant to advanced developers in the audience because they might learn a new way to communicate a technical concept, or avoid a problem from happening in the first place. Before showing you how to create your own proposals with this tool, here are ten ready-to-use CFP ideas for 2025 AWS events.
Each proposal targets real technical challenges I've seen teams face. They range from foundational concepts to advanced implementations, making them suitable for different AWS events and audience levels.
These first two proposals address services that often trip up teams moving to production. I've found these topics consistently resonate at AWS events because they help others avoid mistakes I've seen repeatedly.
Early DynamoDB design decisions significantly impact your application's long-term success. This practical session cuts through the complexity to deliver essential knowledge for building production-ready DynamoDB applications.
Key topics:
- Partition key selection and data distribution
- Single-table design implementation
- Index creation and management
- Capacity planning essentials
- Cost optimization strategies
You'll receive:
- Ready-to-use code examples
- Data modeling templates
- Performance monitoring techniques
- Common pitfall solutions
Learn how to effectively manage S3 storage to reduce costs and improve efficiency. This practical session covers essential strategies for organizing buckets, implementing lifecycle rules, and monitoring data transitions.
Key topics:
- Bucket organization patterns that scale
- Implementing cost-effective lifecycle rules
- Choosing the right storage classes
- Basic monitoring setup
- Common pitfalls and solutions
You'll leave with:
- Ready-to-use bucket structuring strategies
- Working lifecycle rule templates
- Cost optimization techniques
- Monitoring basics
The next set of CFPs tackles the infrastructure decisions that keep teams awake at night. These topics come from questions I hear when teams are scaling their AWS implementations.
Ready to move beyond managing EC2 instances? This session provides practical guidance for teams evaluating containers and serverless architectures, based on real migration experiences and actual outcomes.
What you'll learn:
What you'll learn:
- A framework for choosing between EC2, containers, and serverless based on your specific needs
- Common migration patterns and potential pitfalls to avoid
- Cost and operational impact analysis from real-world case studies
- Practical assessment tools for evaluating your applications
- Concrete examples of successful (and unsuccessful) transitions
Who should attend: Developers and architects currently working with EC2 who want to understand their modernization options. Basic EC2 knowledge is helpful, but no container or serverless experience needed.
Is your VPC infrastructure becoming increasingly complex and difficult to manage? In this practical session, you'll learn systematic approach to cleaning up and organizing your VPC without disrupting production workloads.
We'll cover:
- A proven methodology for documenting and analyzing your current VPC state
- Specific techniques for identifying unused resources and mapping dependencies
- Safe strategies for implementing changes in live environments
- Real-world examples of successful infrastructure cleanup projects
- Common pitfalls to avoid and lessons learned from actual implementations
This session is ideal for cloud engineers and architects dealing with growing infrastructure complexity. Basic familiarity with VPC concepts is helpful, but no advanced expertise is required. You'll leave with practical tools and actionable steps to transform your complex VPC into a well-organized, maintainable infrastructure.
Inherited a messy AWS account? You're not alone. This session provides a practical, tested approach to cleaning up IAM roles and permissions without breaking production systems.
Key topics:
- Systematic assessment of existing IAM configurations
- Tools and scripts for identifying unused roles
- Safe removal strategies for unnecessary permissions
- Documentation and tracking methods
- Prevention of future permission sprawl
You'll leave with ready-to-use scripts, processes, and documentation templates for immediate implementation in your environment.
These talk ideas address the questions that come up once systems are in production - how to measure performance, control costs, and fix issues when they occur.
Lambda functions are easy to deploy but challenging to monitor effectively. What metrics actually matter? How do you know when there's a problem?
This practical session cuts through the complexity of Lambda monitoring to deliver actionable insights. You'll learn:
- How to identify and track the most important Lambda performance metrics
- Practical CloudWatch monitoring setup with working configurations
- Effective logging patterns and code examples
- Real-world interpretation of performance data
- Setting meaningful alert thresholds
You'll leave with ready-to-use monitoring templates and clear guidelines for measuring your function's performance.
Managing AWS costs effectively requires more than just monitoring - it demands practical action. In this session, we'll share real-world techniques for identifying and reducing cloud spending, backed by concrete examples and implementation guides.
You'll learn:
- How to set up effective cost monitoring and alerting using AWS Cost Explorer and Budgets
- Practical methods to identify unused resources and optimization opportunities
- Specific configurations for automating cost management
- Templates and workflows for ongoing cost optimization
- Common pitfalls to avoid when implementing cost controls
You'll leave with ready-to-implement tools, configurations, and processes that can help reduce your cloud spending immediately.
This proposal tackles one of the most challenging aspects of event-driven systems - what to do when things go wrong.
Event-driven architectures in AWS can feel like a black box when things go wrong. This session provides practical, hands-on debugging techniques for developers new to event-driven systems.
Through live demonstrations and real-world examples, you'll learn:
- Essential logging and monitoring setup for event visibility
- How to implement distributed tracing with AWS X-Ray
- Effective use of dead letter queues and event replay
- Practical alert configuration for early problem detection
- Common failure patterns and their solutions
You'll leave with working examples, debugging workflows, and configuration templates you can implement immediately. We'll focus on real incidents, examining both successful and failed approaches to help you debug with confidence.
These final proposals cover the emerging questions teams have about implementing AI and ML in production environments.
Your first SageMaker production deployment will surface challenges that no tutorial prepares you for. After a lot of lessons and real production incidents, I'll share the essential practices that make the difference between reliable deployments and costly mistakes.
This practical session covers:
- Setting up your first production pipeline with proper security and monitoring
- Managing costs before they manage you
- Implementing basic but effective model monitoring
- Essential security configurations that satisfy most compliance requirements
You'll leave with:
- Ready-to-use configuration templates
- Working example code for common deployment patterns
- Practical monitoring setup scripts
- Clear checklist for production readiness
Moving foundation models from proof-of-concept to production requires specific patterns and practices. This session delivers practical, code-driven solutions for building reliable Amazon Bedrock applications.
Key topics:
- Input validation and security best practices
- Cost management and model selection strategies
- Error handling and resilience patterns
- Context management and session handling
- Performance optimization techniques
You'll receive:
- Production-ready code examples
- Testing and monitoring templates
- Implementation patterns for common challenges
- Real-world success and failure scenarios
The CFP ideas in this post started as questions junior developers frequently ask. I used two AI tools from AWS to turn these questions into polished proposals: Amazon Q Developer for gathering technical depth, and PartyRock for crafting the actual CFP content.
Here are the questions that sparked each proposal:
- “What are the best practices for designing and architecting with DynamoDB?”
➡️ DynamoDB Fundamentals: A Practical Guide to Getting Started Right - “How should I structure my S3 buckets and manage data lifecycle?”
➡️ S3 Lifecycle Management: From Basics to Best Practices - “I'm getting tired of managing EC2 instances - should I move to containers or serverless?”
➡️ EC2, Containers, or Serverless? A Practical Guide to AWS Computing Choices - “Our VPC setup is a mess - what's a practical approach to cleaning this up without breaking everything?”
➡️ Untangling Your VPC: A Step-by-Step Cleanup Guide - “I've inherited a messy AWS account - how do I start cleaning up the IAM roles and permissions?”
➡️ From Chaos to Control: A Practical Guide to AWS IAM Cleanup - “How do I know if my Lambda functions are performing well? What should I be measuring?”
➡️ Measuring What Matters: Essential Lambda Performance Metrics - “My AWS bill is climbing - what are the practical steps to identify costs and optimize spending?”
➡️ Practical Steps to Control and Optimize AWS Spending - “Everyone talks about event-driven architecture in AWS - but how do you debug it when it goes wrong?”
➡️ When Events Go Wrong: A Practical Guide to AWS Debugging - “What are the best practices for SageMaker that nobody talks about? Looking for real production experience.”
➡️ Production SageMaker: What I Wish I Knew When Starting - “What are the Amazon Bedrock best practices that most developers had to learn the hard way?”
➡️ Amazon Bedrock: Essential Patterns for Production Success
I started by asking these questions in VS Code using Amazon Q Developer. This gave me detailed technical content to work with - everything from code examples to architectural patterns. Here's what this looked like for the DynamoDB talk:
Image not found
Pasting the full answer here will make this (already long) blog much longer, but you can view the full response in this snapshot of my PartyRock app.
I built a simple app in PartyRock with three main components:
A. Dropdown to select skill level of the talk:
- 100: Introductory
- 200: Intermediate
- 300: Advanced
- 400: Expert
B. User Input widget called TECHNOLOGY_TOPIC widget where I paste:
- The original developer question
- The technical response from Amazon Q Developer
C. A CFP Helper chatbot
The CFP Helper uses a specific prompt I developed to ensure each proposal includes:
The CFP Helper uses a specific prompt I developed to ensure each proposal includes:
- A clear title that avoids marketing language
- Practical takeaways and code examples
- Prerequisites and target audience
- Real-world context and applications
Image not found
PartyRock lets you capture and share specific moments within an app through snapshots. These are interactive captures that show both the inputs (the original question and Amazon Q Developer response) and outputs (the generated CFP) for each proposal.
Think of these snapshots as interactive screenshots - they preserve the exact state of the app when each CFP was generated. You can see the skill level selected, the technical content provided, and how the CFP Helper transformed this into a conference proposal.
Here are the snapshots for each talk proposal:
- Foundation Topics:
- Infrastructure and Operations:
- Monitoring and Optimization:
- Debugging and Troubleshooting:
- AI and ML Implementation:
One of the hidden gems in PartyRock is that you can view the prompts being used - so you can go from just interacting with AI to learning to write your own prompts. When you click into my prompt, you'll see it's very detailed and specific - this is because I have a lot of experience writing CFPs and wanted to share everything I've learned to make these proposals as successful as possible!
While I designed this app for CFPs, you can use it with different inputs:
- Blog posts you've written
- Study notes or documentation
- Technical specifications
- Meeting notes or project discussions
This isn't the traditional way to use Amazon Q Developer, but it's a great head start if you need some points to cover in your talk.
You can remix this app to create your own version. Remixing in PartyRock is like forking a project - you take the existing app as a starting point and modify it to suit your needs. You can modify the prompts, change the layout, add new widgets, or customize it for different types of events or topics.
For example - in the snapshots you'll be able to see that I actually made both short and long versions of each talk proposal. I found this worked better for the outcomes I was looking for, but you can change my prompt to suit yourself!
I put heaps of effort into making this app as good as possible because I want to save our community time! My goals are:
- Make it easier for people to deliver their first talk
- Help conference organizers and AWS User Group Leaders find speakers for their 2025 events in a new way
- Provide a starting point for anyone interested in speaking but unsure where to begin
If you use any of these CFP ideas to submit your first talk proposal, deliver a talk based on them, remix the app for your needs, or use these templates to organize an event - I'd love to hear about it in the comments!
Conference organizers: feel free to use these CFP templates to inspire your 2025 call for speakers. They're designed to help you find speakers who can deliver practical, valuable content for your audiences.
First-time speakers: pick a topic you're passionate about, adapt one of these proposals to match your experience, and submit it. Every experienced speaker started with their first talk, and the AWS community is always eager to hear fresh perspectives.
Any opinions in this post are those of the individual author and may not reflect the opinions of AWS.
Comments
Log in to comment