AWS Builder Center
Weekend Showcase Challenge: StudyPulse — An Autonomous AI Study Agent That Remembers, Adapts, and Acts

Weekend Showcase Challenge: StudyPulse — An Autonomous AI Study Agent That Remembers, Adapts, and Acts

StudyPulse connects a simple web app with AWS services to turn student input into a personalized study plan. API Gateway sends requests to Lambda, which retrieves learning history from DynamoDB and uses Amazon Bedrock with Nova Micro to generate the plan. The result is stored back in memory and delivered through the web app and SES. EventBridge Scheduler can also trigger the agent automatically, making StudyPulse useful even when the student does not manually start it.

AWS Student Captain | Cloud & AI Builder | Cybersecurity | Always Building, Always Learning
What if your study planner didn't wait for you to open it?
What if it remembered what you struggled with yesterday, understood how much time you actually had today, and could prepare a focused plan instead of making you start from a blank page every morning?
That was the idea behind StudyPulse.
For the Summer Builds Showcase, I took my earlier StudyPulse build and pushed it beyond being just another AI study planner. I wanted to turn it into something closer to an autonomous study companion — one that can use persistent learning context, generate a personalized plan with Amazon Bedrock, remember what it generated, and deliver the result through email.
The result is a serverless AI study agent built almost entirely with AWS services.

Vision & What It Does

Students often know what they need to study but struggle with deciding what to do next.
A traditional planner gives you a fixed timetable. A chatbot gives you an answer when you ask. StudyPulse is designed to sit somewhere in between: it uses stored context and AI reasoning to make the planning process adaptive.
In the showcase version, a student can interact with StudyPulse by providing information such as:
  • What they want to study
  • How much time they have available
  • Their difficulty level
  • Their current goal
StudyPulse combines that input with stored learning memory such as subjects, upcoming exams, weak topics, previously completed topics, and the previous generated plan.
The agent then asks Amazon Nova Micro to create a focused plan for the current session.
The output is structured around:
Today's Priority → Why → Study Plan → Challenge
The final challenge is intentional. I didn't want StudyPulse to simply tell students what to read. I wanted it to encourage active recall and make the learner actually engage with the material.
The generated plan is also stored back into DynamoDB, allowing future runs to have context about what happened previously instead of treating every request as a completely new conversation.
And because this is an autonomous-agent project, the workflow can also deliver the generated plan through Amazon SES rather than requiring the student to keep the application open.


How I Built It

The project started as a simple idea: generate a personalized study plan using AI.
But during the Summer Build Series, I kept pushing the question:
What would make this feel like an agent instead of just an AI button?
That led me toward persistent memory, automation, serverless execution, and proactive delivery.
The architecture became:
Student → S3-hosted Web App → API Gateway → AWS Lambda → DynamoDB + Amazon Bedrock → DynamoDB → Amazon SES
The frontend provides the interactive experience, while API Gateway exposes the backend endpoint. Lambda acts as the orchestration layer. It retrieves the student's stored context from DynamoDB, constructs the AI prompt, invokes Amazon Nova Micro through Amazon Bedrock, saves the generated plan, and sends the result through SES.
For the autonomous side of the project, StudyPulse also uses scheduled AWS execution so the system can operate without requiring the student to manually trigger every workflow.
The entire architecture is serverless, which made it possible to build and iterate quickly without managing traditional servers.

The Part That Didn't Go According to Plan

Honestly, getting here was not a straight line.
One of the first problems I encountered was Amazon Bedrock rejecting the initial model invocation because the model required an inference profile. I also encountered the infamous:
 ValidationException: The provided model identifier is invalid. 
That forced me to stop treating the model identifier as a simple string and understand how Amazon Bedrock model access and inference profiles actually work. I eventually moved to the appropriate regional inference profile for Amazon Nova Micro.
Then came DynamoDB.
The Lambda function successfully generated the plan, but saving the result failed with an  AccessDeniedException  because the Lambda execution role didn't have permission to perform the required  UpdateItem  operation.
That was a surprisingly useful failure.
It reminded me that building an AI application is not only about the AI model. The surrounding cloud architecture — IAM permissions, data access, API integration, deployment, and observability — has to work as one system.
I also had to troubleshoot the connection between the frontend and API Gateway and make sure the deployed S3 website could actually communicate with the backend.
Eventually, the pieces started falling into place.
The most satisfying moment wasn't seeing the AI generate text.
It was seeing the complete chain work:
input → API → Lambda → memory → Bedrock → generated plan → memory update → email
That was when StudyPulse stopped feeling like a collection of AWS services and started feeling like an actual system.

AWS Services Used & Architecture

Amazon S3

Hosts the StudyPulse frontend as a deployed static web application.

Amazon API Gateway

Provides the HTTP endpoint used by the frontend to communicate with the backend.

AWS Lambda

Acts as the serverless agent orchestration layer. It retrieves memory, prepares the prompt, invokes Bedrock, updates memory, and triggers email delivery.

Amazon DynamoDB

Provides persistent student memory.
StudyPulse stores information such as the student's learning context, previous plan, completed topics, and other planning information so that the agent can make future decisions using historical context.

Amazon Bedrock + Amazon Nova Micro

Provides the generative intelligence behind StudyPulse.
Nova Micro receives the student's current context and produces the personalized study plan.

Amazon SES

Delivers the generated study plan through email, turning the application from something a student simply visits into something that can proactively deliver useful output.

Amazon EventBridge Scheduler

Supports the autonomous scheduling layer, allowing StudyPulse workflows to run according to a schedule instead of depending entirely on manual interaction.

IAM

Controls which AWS resources the Lambda function can access.
This project made it very clear to me that IAM is not an afterthought — it is part of the architecture.

What Makes StudyPulse Useful?

The biggest difference is context.
A generic AI prompt might produce:
"Study Chapter 1, revise your notes, and solve some questions."
StudyPulse is designed to reason from information such as:
What am I studying? How much time do I have? What am I weak at? What did I complete previously? What is my current goal? What did the agent recommend before?

That makes the output much more actionable.
The student doesn't have to spend ten minutes deciding what to do before actually studying.
The goal is simple:
Less planning. More learning.
And because the architecture includes persistent memory, the long-term vision is to make the recommendations increasingly contextual rather than repeatedly generating the same generic study routine.

What I Learned Across the Summer

The biggest lesson from the Summer Build Series was that an AI application becomes much more interesting when you stop thinking only about the model.
I learned how to connect generative AI with real cloud infrastructure.
I worked with Amazon Bedrock and Nova models, serverless Lambda functions, DynamoDB persistence, API Gateway, SES email delivery, S3 deployment, EventBridge scheduling, and IAM permissions.
More importantly, I learned how these services interact.
I learned that a  ValidationException  can lead to understanding inference profiles.
An  AccessDeniedException  can lead to understanding IAM properly.
A broken API connection can teach you more about serverless architecture than a successful first deployment.
And a working AI response is only one part of a successful application.
The real challenge is building the system around it.

Final Thoughts

StudyPulse started as a simple weekend experiment.
It evolved into an autonomous study-planning system with memory, generative AI, serverless infrastructure, scheduled execution, and proactive email delivery.
The Summer Builds Showcase gave me the opportunity to take that earlier idea and give it the finishing touches it needed.
I'm especially grateful for the builders who made these summer challenges feel like a continuous learning journey. Seeing projects such as The Museum That Grows by Lewis Sawe pushed me to think beyond the usual "input → AI → output" pattern and ask what an application can do when it has memory and autonomy.
This is my final summer build — but hopefully not the final version of StudyPulse.

🔗 Try StudyPulse

Github Link :
StudyPulse is deployed using AWS and demonstrates a working end-to-end flow from user interaction to AI-generated output.
If you try it, I'd love to know:
What would you want an AI study agent to remember about you?


Built with ☁️ AWS + 🤖 Amazon Bedrock + 🧠 Amazon Nova Micro + ⚡ AWS Lambda + 🗄️ DynamoDB + 📧 Amazon SES
Tagging a builder who inspired this journey: @Lewis Sawe
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article