10 Days of Building AI Agents on AWS | Day 5
Meetings are essential for collaboration, but they often create another problem: someone has to spend time reviewing notes, writing summaries, extracting action items, and documenting key decisions.
Whether it is a team stand-up, client discussion, or project planning session, this repetitive work can sometimes take almost as long as the meeting itself.
To solve this problem, I built Meeting2Tasks, an AI-powered web application that automatically transforms meeting transcripts into structured summaries, actionable tasks, key decisions, risks, and unanswered questions.
Instead of manually organizing notes after every meeting, users simply paste their meeting transcript, and the application does the rest in seconds.
The Problem
One of the most repetitive tasks in project management is documenting meetings.
After almost every meeting, someone needs to:
- Read through lengthy meeting notes or transcripts
- Summarize the discussion
- Identify action items
- Record important decisions
- Highlight project risks
- Capture unanswered questions
- Save everything so it can be reviewed later
This process is repetitive, time-consuming, and can result in inconsistent documentation.
I wanted to build a tool that could eliminate much of this manual work while producing structured and consistent results.
What Meeting2Tasks Does
Meeting2Tasks is a web application designed to automate meeting documentation.
Users simply:
- Paste a meeting transcript
- Click Analyze
- Let AI process the conversation
- Receive structured insights
The application generates:
- A concise meeting summary
- Actionable tasks
- Important decisions
- Identified risks
- Open questions
Once the analysis is complete, the application stores the meeting and its generated insights in Amazon DynamoDB.
Users can revisit previous meetings whenever needed, while the dashboard provides statistics and access to meeting history.
The result is a faster and more organized workflow for teams that regularly conduct meetings.
How It Works
The workflow is straightforward:
Meeting Transcript → AI Analysis → Structured Insights → Stored Meeting History
When a user submits a transcript, the application sends it through the backend for AI analysis.
The Groq API processes the meeting content and returns structured results.
These results are then stored in DynamoDB for future access.
User submits transcript
│
▼
React + Vite Frontend
│
▼
Amazon API Gateway
│
▼
AWS Lambda
│
┌────┴─────┐
▼ ▼
Groq API DynamoDB
│ │
└────┬─────┘
▼
Structured Meeting Insights
How I Built It
The application consists of a React frontend and a serverless backend running on AWS.
Frontend
The frontend was developed using:
- React
- Vite
This provides a fast and responsive interface for submitting transcripts, viewing results, and accessing previous meetings.
The frontend communicates with a REST API exposed through Amazon API Gateway.
Backend
The backend uses:
- Express.js
- Node.js
- AWS Lambda
The Express.js application runs inside AWS Lambda, allowing the backend to scale automatically without managing traditional servers.
When a user submits a transcript, the backend processes the request and sends the transcript to the Groq API.
The AI then generates structured insights including summaries, tasks, decisions, risks, and open questions.
The processed results are stored in Amazon DynamoDB.
Deployment
The frontend is deployed using AWS Amplify.
The backend infrastructure is built and deployed using AWS SAM, which helps define and manage the serverless application.
Using this architecture allowed me to focus more on building the application instead of managing servers and infrastructure manually.
AWS Services Used
AWS Amplify
Used to host and deploy the React frontend.
This makes the application publicly accessible and simplifies frontend deployment.
Amazon API Gateway
Provides REST API endpoints connecting the frontend with the backend.
AWS Lambda
Runs the Express.js backend in a serverless environment.
The backend executes when requests arrive without requiring an always-running server.
Amazon DynamoDB
Stores:
- Meeting records
- AI-generated summaries
- Action items
- Decisions
- Risks
- Open questions
This allows users to revisit and manage previous meeting results.
AWS SAM
AWS Serverless Application Model was used to:
- Define the backend infrastructure
- Build the serverless application
- Test deployments
- Deploy Lambda and API resources
Groq API
Groq handles the AI analysis.
It transforms raw meeting transcripts into structured and actionable insights.
Architecture Overview
The complete architecture looks like this:
User
│
▼
React + Vite Frontend
│
▼
AWS Amplify
│
▼
Amazon API Gateway
│
▼
AWS Lambda (Express.js)
│
┌─────────┴─────────┐
▼ ▼
Groq API Amazon DynamoDB
│ │
└─────────┬─────────┘
▼
AI Analysis and Stored Meetings
The workflow starts whenever a user submits a meeting transcript through the web application.
The backend handles the AI request, processes the response, stores the relevant data, and returns structured results to the user.
Challenges I Faced
Like most real-world projects, building Meeting2Tasks involved several technical challenges.
Running Express.js with AWS Lambda
One of the biggest challenges was integrating an Express.js application with AWS Lambda while ensuring API Gateway correctly routed requests.
This required understanding how a traditional web framework could work inside a serverless execution environment.
DynamoDB Reserved Attribute Names
I also encountered issues with DynamoDB because some attribute names conflicted with reserved words.
This required modifying database queries and expressions to avoid those conflicts.
It was a useful reminder that database design and query syntax need careful attention, even in serverless applications.
Deployment to the Wrong AWS SAM Stack
Another significant challenge involved deployment.
During debugging, I discovered that updates were being deployed to the wrong AWS SAM stack.
This caused new API routes not to appear in production, even though everything worked correctly locally.
After identifying the stack configuration issue and deploying to the correct stack, all endpoints functioned as expected.
This experience helped me better understand:
- Serverless deployments
- Stack configuration
- Production debugging
- The difference between local and deployed environments
What I Learned
Building Meeting2Tasks gave me valuable hands-on experience with modern serverless application development.
Some of the key things I learned include:
Building Serverless APIs
How to build REST APIs using AWS Lambda and API Gateway without managing traditional servers.
AWS SAM Deployments
How AWS SAM can simplify building, testing, and deploying serverless applications.
Hosting React Applications
How AWS Amplify can be used to deploy and host a modern React frontend.
Serverless Architecture Design
How services such as API Gateway, Lambda, and DynamoDB can work together as a complete backend architecture.
Integrating External AI
How to connect an external AI service such as Groq with an AWS-based application.
Debugging Deployments
How configuration mistakes, stack selection, and deployment environments can cause production issues even when an application works locally.
Persistent Data with DynamoDB
How DynamoDB can store application data and make AI-generated results available for future use.
Why This Matters
The main idea behind Meeting2Tasks is simple.
Teams should spend more time making decisions and completing important work, not repeatedly documenting conversations.
AI can help automate the repetitive part.
Instead of manually reviewing a long transcript, users can receive structured information within seconds.
Transcript → Summary → Tasks → Decisions → Risks → Questions
This does not replace the meeting itself. It reduces the administrative work that follows it.
Final Thoughts
Meeting2Tasks started with one simple problem: manually documenting meetings is repetitive and time-consuming.
By combining AI with serverless AWS technologies, I built an application that transforms lengthy meeting transcripts into structured, actionable insights within seconds.
The project demonstrates how AI can help eliminate repetitive work while allowing teams to focus more on making decisions instead of documenting them.
It also showed me how services such as AWS Lambda, API Gateway, DynamoDB, Amplify, and SAM can work together with an external AI provider to build a scalable application.
Source Code and Live Application
GitHub Repository:
Meeting2Tasks on GitHub
Live Application:
Open Meeting2Tasks
Top comments (0)