AWS Builder Center
Weekend Creative Agent Challenge: DawnVerse

Weekend Creative Agent Challenge: DawnVerse

DawnVerse is an always-on AI poet that wakes up every morning, writes a fresh poem themed to the day, and stores it automatically. Built with AWS Lambda, EventBridge Scheduler, Bedrock Nova Micro, and DynamoDB, it proves creative AI can work proactivel,not only when someone presses a button.

Student at MSRIT

DawnVerse

Vision and what it does

Last week I built a creative app. This week I wanted to explore the same kind of writing, but without me having to open anything, press a button, or remember to ask for it.
DawnVerse is an always-on daily poem agent. It wakes up on its own every morning, understands what day it is, writes something new themed around that day, and leaves the finished poem waiting on a public page.
The problem it solves is intentionally small, but that is exactly the point of the project. A creative tool that only works when I remember to prompt it is still a chore. The more interesting version is one that has already done the work before I sit down.
Every morning at 06:00 India Standard Time, Amazon EventBridge Scheduler invokes an AWS Lambda function. The function checks today's date in  Asia/Kolkata . If a poem for that date already exists, it stops immediately. If not, it retrieves the three most recent poems from Amazon DynamoDB and gives them to Amazon Bedrock Nova Micro as short-term creative memory.
The prompt tells Nova not to repeat the previous poems' titles, imagery, or closing lines. It then writes a 10-to-16-line poem themed around the weekday — Saturday might become market fruit and crowded streets, Monday might become kettle steam and the start of a new week, while Sunday might become leftover cake and a slower morning.
Lambda stores the completed poem in DynamoDB. A Lambda Function URL exposes a simple, read-only gallery where the poems can be viewed.
There is deliberately no generate button.
When I come back, the work is already there.
The first morning after deployment, I invoked the function once from the CLI so the gallery would not sit empty until the scheduled run. After that, the schedule owns the work.
Today's poem is titled Morning Stroll. It was written at 01:15 IST on 22 August 2026, while I was still setting the stack up, and it was waiting for me when I opened the gallery.



How I built it

I chose AWS SAM on purpose. I wanted one template, one build, and one deploy instead of a pile of console configuration that would be difficult to reproduce later.
 template.yaml  describes the DynamoDB table, Python 3.12 Lambda, Lambda Function URL, IAM permissions, and EventBridge Scheduler configuration.  sam build  packages the application, while  sam deploy  creates the CloudFormation stack in  us-east-1 .
The most important product decision was to keep the write path completely separate from the page.
HTTP GET requests only render HTML or return JSON. They never invoke Bedrock and never generate a poem.
Scheduler events call  write_todays_poem() .
That separation matters because if opening the gallery could trigger Bedrock, DawnVerse would still fundamentally be an app that I have to interact with. Instead, the architecture makes the agent responsible for the creative work while the website is simply the place where the finished work is left.
The agent writes. The page only shows.
I also deliberately kept everything inside a single Lambda function instead of splitting the writer and gallery into separate functions. Sharing one function meant I could avoid a second IAM role, another deployable, and additional infrastructure while keeping the two execution paths logically separate.
DynamoDB uses a partition key of  POEM  and a date-based sort key. This means retrieving recent poems can be done as a reverse query rather than scanning the entire table.
Idempotency was another important design decision.
The scheduler can potentially retry an invocation. The Lambda can also be manually triggered during development. I did not want either case to create duplicate poems for the same day.
So the function checks whether today's poem already exists before generating anything. If it does, the function exits.
This gives DawnVerse a simple guarantee:
one day → one poem.
lambda function

cloudwatch logs




The tooling challenge

The hardest part of the project was honestly not the poetry. It was getting the AWS tooling into a clean state on Windows.
AWS CLI and SAM were not installed on this machine initially. I wanted to avoid filling up the system drive, so I placed Python, SAM CLI, and AWS CLI under  D:\Tools .
SAM's Windows MSI also refused to perform a silent repair after an interrupted installation. Instead of fighting the installer further, I installed SAM through pip using the Python installation on the D: drive.
AWS credentials were kept under  D:\Tools\aws , keeping the development environment organized and away from the system drive.
Once the deployment finally succeeded, the first Bedrock invocation produced Morning Stroll instead of failing. Nova Micro was already ACTIVE in  us-east-1 , so I did not need to introduce an inference profile just to make the project work.
That kept the Lambda handler relatively small and the deployment architecture straightforward.



Style memory: the small detail that made it feel more like an agent

One of my favorite parts of DawnVerse is also one of the simplest.
Before writing a new poem, Lambda retrieves the three most recent poems and passes them into the prompt as memory.
The instruction is essentially:
Do not repeat their titles, images, or closing lines.
This means the model is not generating every poem in isolation.
If yesterday's poem used rain on windows and ended with a particular image, today's poem has that context available. Over time, the agent gets a small memory of what it has already said and can deliberately move somewhere else.
It is a lightweight form of persistent creative memory without requiring model fine-tuning or a separate training pipeline.
That was the Level 200 detail that cost almost nothing to implement but made the agent feel much less repetitive.



AWS services used

AWS Service
Role in DawnVerse
Why I used it
Amazon EventBridge Scheduler
Wakes the agent every morning at 06:00 IST
Turns the poem generator into an always-on agent instead of something that needs a manual prompt
AWS Lambda
Runs the poem-generation logic and serves the gallery
Serverless, lightweight, and handles both scheduled execution and HTTP requests
Amazon Bedrock – Nova Micro
Generates the daily poem
Fast, lightweight, and well suited for short creative generations
Amazon DynamoDB
Stores poems and recent creative memory
Serverless storage with efficient date-based queries and no table scans
AWS Lambda Function URL
Provides the public read-only gallery
Simple way to expose the finished poems without adding API Gateway
Amazon CloudWatch Logs
Records Lambda executions and scheduler runs
Makes it possible to verify that the agent actually woke up and ran
AWS IAM
Controls Lambda and Scheduler permissions
Keeps access limited to the resources each component actually needs
AWS SAM / CloudFormation
Defines and deploys the infrastructure
Makes the entire project reproducible from a single template.yaml



Architecture

EventBridge Scheduler
06:00 IST every day
|
v
+-------------+
| AWS Lambda |
+-------------+
| |
| +----------------+
| |
v v
DynamoDB Bedrock Nova
Recent Poems / Memory Micro
| |
+------------+-------------+
|
v
Store Today's Poem
|
v
Lambda Function URL
|
v
Read-only Gallery

The architecture is intentionally small.
EventBridge provides the trigger. Lambda coordinates the work. Bedrock provides the creative generation. DynamoDB provides memory and persistence. The Function URL exposes the finished result.
There is no frontend-to-model generation loop and no server waiting for someone to click a button.
The creative work happens before the user arrives.



How the daily generation works

The daily flow is essentially:
1. EventBridge wakes Lambda
At 06:00 IST, the Scheduler invokes the Lambda function.
The cron expression is:
 cron(30 0 * * ? *) 
That is 00:30 UTC / 06:00 IST.
2. Lambda checks today's date
The function calculates the current date using  Asia/Kolkata  rather than relying blindly on the Lambda runtime's timezone.
3. Idempotency check
DynamoDB is checked for today's poem.
If one already exists, generation stops immediately.
4. Retrieve creative memory
If today's poem does not exist, Lambda retrieves the three most recent poems.
5. Generate
The weekday, recent poems, and style instructions are sent to Amazon Bedrock Nova Micro.
6. Store
The generated poem is written to DynamoDB.
7. Wait
The agent is finished.
The next interaction is simply someone opening the gallery and discovering that today's poem has already been written.



Why there is no Generate button

This might be the smallest feature in the application, but it is probably the most important one.
A traditional AI writing app usually works like this:
User opens app
↓
User thinks of prompt
↓
User clicks Generate
↓
AI writes

DawnVerse works like this:
Time arrives
↓
Agent wakes up
↓
Agent checks memory
↓
AI writes
↓
Poem waits
↓
User discovers it

That difference is the entire experiment.
The model itself is not what makes DawnVerse feel autonomous. The schedule, persistence, memory, and idempotency are what turn a model call into an agent.



What I learned

The biggest thing I learned is that an always-on agent is mostly about the trigger.
The model call itself is almost the same call I would make behind a normal "Generate" button. The difference is everything surrounding it:
  • EventBridge decides when the agent wakes up.
  • Lambda performs the work.
  • DynamoDB gives it memory.
  • Idempotency prevents duplicate work.
  • The gallery gives the result somewhere to wait.
  • The read path stays away from the expensive generation path.
That architecture changed how I think about agents.
The interesting part is not always making the model smarter. Sometimes it is making the model show up at the right time without being asked.
I also learned that keeping the read path from being able to spend Bedrock tokens is an important product constraint. If someone refreshes the gallery twenty times, that should still only show the poem that was already generated that morning.
I learned that SAM on Windows is straightforward once Python and the CLI are correctly configured, but frustrating when an MSI installation gets left half-registered. Using a local Python installation and pip ended up being the reliable path for this setup.
I also learned that Nova Micro can be called directly with its model ID here, rather than introducing an inference profile, which kept the implementation smaller.



What I would build next

If I extend DawnVerse, the first upgrade would be to make the daily theme responsive to the real world.
Instead of only knowing that it is Saturday, the agent could also look at local weather and incorporate that into the poem. A rainy Saturday could produce something completely different from a bright one.
Another possible extension would be using Amazon SES to send the completed poem directly to me each morning.
I could also imagine adding different recurring creative agents: a daily haiku, a tiny short story, a daily visual prompt, or even a weekly piece that remembers the previous week's work.
But for this weekend, I wanted to keep the idea focused.
A scheduled poet with a waiting page was enough.
The goal was simple:
Make something new on its own, and have it ready when I return.



Link to app and repo

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