AWS Builder Center
Weekend Creative Agent Challenge: StudyPulse

Weekend Creative Agent Challenge: StudyPulse

StudyPulse is an autonomous AI study agent that uses Amazon Bedrock, DynamoDB, Lambda, EventBridge, and SES to remember a student's learning context, generate personalized daily study plans, and deliver them automatically.

AWS Student Captain | Cloud & AI Builder | Cybersecurity | Always Building, Always Learning

Introduction

What if I didn't have to open an AI chatbot every morning and ask, "What should I study today?"
That was the idea behind StudyPulse, an autonomous AI study agent I built for the AWS Weekend Creative Agent Challenge.
As a student, I know that deciding what to study can sometimes be almost as difficult as actually studying. There are multiple subjects, weak topics, upcoming exams, limited time, and yesterday's unfinished work to think about.
I wanted to build something small that could take some of that decision-making off my plate.
The goal wasn't to build another chatbot. I wanted to build something that could run on its own.
StudyPulse stores a student's learning context, uses Amazon Bedrock and Amazon Nova Micro to generate a personalized study plan, saves the result, and sends it by email. The whole workflow can be triggered automatically using Amazon EventBridge Scheduler.
The idea is simple:
Remember → Reason → Plan → Deliver → Repeat.



What StudyPulse Does

StudyPulse is a serverless AI agent that creates a personalized study plan based on information stored about a student.
The memory currently includes things like:
  • Current subjects
  • Upcoming exam
  • Weak topics
  • Available study time
  • Previous study plan
Instead of asking the student for this information every time, the agent retrieves the stored context from DynamoDB and gives it to the AI model.
The model then decides what deserves attention today and generates a short plan containing:
  1. A priority topic
  1. Why that topic was selected
  1. Specific study tasks
  1. A challenge question
The generated plan is saved back to DynamoDB and delivered to the student through Amazon SES.
The important part is that the student doesn't have to manually start the process every day.



Why I Built It

I wanted to understand what makes an AI application feel like an agent rather than simply an application that sends a prompt to an LLM.
For me, the interesting part wasn't just getting Nova Micro to generate text. It was connecting the model to memory, an automated trigger, persistent state, and an actual action.
StudyPulse uses:
  • Amazon DynamoDB for student memory
  • Amazon Bedrock + Amazon Nova Micro for AI reasoning and study-plan generation
  • AWS Lambda to orchestrate the workflow
  • Amazon EventBridge Scheduler to trigger the agent automatically
  • Amazon SES to deliver the finished study plan
This turns a single AI response into an automated workflow.



How StudyPulse Works

The architecture is intentionally simple and serverless.
The workflow starts with Amazon EventBridge Scheduler.
At the scheduled time, EventBridge triggers the StudyPulse Lambda function.
Lambda first retrieves the student's information from the  StudyPulseMemory  DynamoDB table.
For example, the stored information might look conceptually like:
Upcoming exam: AZ-104
Weak topics: Networking
Available study time: 45 minutes
Previous plan: Networking fundamentals
Lambda then builds a prompt using this context and sends it to Amazon Bedrock, using the Amazon Nova Micro inference profile.
Nova Micro generates the study recommendation.
Lambda receives the response and then performs two actions:
  1. Saves the new study plan back into DynamoDB.
  1. Sends the study plan to the student through Amazon SES.
So the complete flow is:
EventBridge Scheduler
↓
AWS Lambda
↓
Retrieve student memory
↓
Amazon DynamoDB
↓
Amazon Bedrock / Nova Micro
↓
Generate study plan
↓
AWS Lambda
↙ ↘
DynamoDB Amazon SES
↓
Student



The AI Agent

The prompt was one of the parts I spent time refining.
I didn't want the model to simply generate a generic motivational study plan. It needed to make its recommendation based on the student's actual stored context.
I instructed the model to prioritize weak areas, consider the available study time, avoid unnecessarily repeating previous plans, and avoid inventing information about the student.
The output follows a structured format:
TODAY'S PRIORITY:
Networking

WHY:
Networking remains a weak topic and is important
for the upcoming exam.

STUDY PLAN:
1. Review key networking concepts
2. Study route tables
3. Practice configuring a route table

CHALLENGE:
Explain how to associate a route table with a subnet.
Keeping the output structured made it easier to display, store, and send through email.
It also made the agent's behavior more predictable.




Memory with DynamoDB

One of the parts I particularly liked about this project was giving the agent memory.
The  StudyPulseMemory  DynamoDB table stores the student's learning context along with the previously generated plan.
After each run, the new plan is saved.
That creates a simple feedback loop:
Student memory
↓
AI generates today's plan
↓
Plan is saved
↓
Updated memory is available
↓
Future agent runs
This is what makes StudyPulse more than a one-off LLM prompt.
The agent has some context about where the student currently is and what it recommended previously.




What Broke Along the Way

The project definitely did not work perfectly on the first attempt.
The first major issue happened when I tried to invoke Amazon Nova Micro using the base model identifier.
I received a validation error saying that on-demand invocation wasn't supported for that model configuration and that I needed to use an inference profile.
After checking the inference profiles available in my AWS region, I switched to:
apac.amazon.nova-micro-v1:0
That resolved the model invocation problem.
The second issue was an IAM permission error.
Lambda successfully generated the study plan but then failed when trying to update DynamoDB.
The error showed that the Lambda execution role didn't have permission to perform:
dynamodb:UpdateItem
on the  StudyPulseMemory  table.
After adding the required permission to the Lambda execution role, the workflow could successfully save the generated plan.
The final integration test showed:
Student memory loaded successfully.
Study plan generated successfully.
Study plan saved to DynamoDB.
Email accepted by Amazon SES.
Then there was one more small surprise.
The first StudyPulse email actually landed in my spam folder.
So technically the AWS workflow was working, but Gmail had other plans. 😭
It was a useful reminder that building a real application isn't just about getting the code to run. The systems around it matter too.



From a Manual Test to an Autonomous Agent

During development, I initially triggered Lambda manually because I needed a quick way to test each part of the workflow.
But the whole point of the challenge was to build something that could work on its own.
So I added Amazon EventBridge Scheduler as the trigger.

The interaction changes from:
Student
↓
Manually trigger Lambda
↓
Receive study plan
to:
EventBridge Scheduler
↓
StudyPulse Agent
↓
Personalized study plan
↓
Amazon SES
↓
Student
The student doesn't need to remember to start the agent.
The schedule starts it.
This was probably the part that made the project feel most like an agent to me. The system can wake up, retrieve its context, use AI to make a decision, perform actions, and deliver the result without requiring a manual prompt.



The Final Result

The final output isn't just a response sitting inside the Lambda console.
StudyPulse actually delivers the generated plan to the student.
For example, one of my test runs generated a plan focused on networking because it was stored as a weak area for my AZ-104 preparation.
The email contained the day's priority, why it was selected, the study tasks, and a challenge question.
That small transition—from AI-generated text to a useful action delivered automatically—is what I wanted to achieve with this project.



AWS Services Used

The project uses the following AWS services:
Amazon EventBridge Scheduler — triggers the agent automatically.
AWS Lambda — acts as the main orchestration layer.
Amazon DynamoDB — stores student memory and previously generated study plans.
Amazon Bedrock — provides access to the foundation model.
Amazon Nova Micro — generates the personalized study recommendation.
Amazon SES — delivers the generated study plan through email.
I deliberately kept the architecture small and serverless because the goal was to build something useful quickly without introducing unnecessary infrastructure.



What I Learned

The biggest lesson I took away from this challenge is that an AI agent is more than an LLM generating text.
The useful part comes from connecting intelligence to:
  • Memory
  • Triggers
  • Actions
  • Persistent state
  • Real-world delivery
I also got hands-on experience with several AWS concepts that I had previously understood mostly in isolation.
I learned how inference profiles affect Amazon Bedrock model invocation, how IAM permissions can break an otherwise working Lambda function, how DynamoDB can provide simple persistent memory, and how EventBridge can turn a manually triggered workflow into an autonomous one.
I also learned that debugging cloud applications is often about following the chain of permissions and service interactions rather than looking only at the code.
The errors I encountered were actually some of the most useful parts of the project.



What's Next

StudyPulse is intentionally a small first version, but there are plenty of directions I could take it.
The next version could track whether a student actually completed each task and use that information to adjust future recommendations.
It could also support multiple subjects, maintain progress over time, generate adaptive quizzes, and increase revision intensity as an exam approaches.
A dashboard could eventually show the student's progress and the topics the agent has recommended over time.
For this challenge, though, I wanted to resist the temptation to keep adding features.
The core idea was enough:
A small AI agent that remembers, decides, and acts without being asked every time.



Conclusion

StudyPulse started with a simple question:
Can an AI agent decide what a student should study today and take care of the rest automatically?
The result is a small but functional autonomous workflow built with AWS.
It retrieves student memory from DynamoDB, uses Amazon Bedrock and Nova Micro to generate a personalized study plan, saves the result, and delivers it through Amazon SES—all triggered automatically through EventBridge Scheduler.
Building it also showed me something I hadn't fully appreciated before starting this challenge: the interesting part of an AI application isn't always the model itself.
The real value comes from everything around the model.
Memory gives it context.
A scheduler gives it autonomy.
Lambda gives it a way to act.
AWS services give it the infrastructure to actually do something with the model's output.
And the final email turns that output into something useful for a real person.
Sometimes the most useful agent isn't the one that does a hundred things.
It's the one that quietly does one useful thing every day without being asked.
Remember → Reason → Plan → Deliver → Repeat.




Source Code

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