AWS Builder Center
Weekend Creative Agent Challenge: Daily Postcard Agent

Weekend Creative Agent Challenge: Daily Postcard Agent

An always-on AWS agent that checks the weather each morning, writes a poem, and paints a matching postcard with Amazon Bedrock — publishing the result to a public gallery before you've even opened your laptop. Built serverless on Lambda, EventBridge Scheduler, S3, and DynamoDB, with a feedback loop that nudges its own visual style forward day over day.

AWS Cloud Captain at MIT-ADT University

Weekend Creative Agent Challenge: Daily Postcard Agent

Vision and what it does

Most "creative AI" projects require you to show up: open an app, type a prompt, wait, download. The Weekend Creative Agent Challenge asked for the opposite — something that works while you're not looking, and has a result ready when you get back. I built Daily Postcard Agent, a fully serverless AWS agent that wakes up on its own every morning, checks the real weather, writes a short poem about the day, paints a matching postcard illustration, and publishes both to a public gallery — with zero manual steps after deployment.
The problem it solves is small but real: I like the idea of a daily creative ritual (a poem, a piece of art, a little moment of "what did today look like?") but I never actually keep up one manually. An agent that just does it, on a schedule, and leaves the result somewhere I can check later, removes the friction entirely. It also directly answers the challenge's own idea list — it's a daily-art agent, it themes its output to the weather, and it's designed to evolve its own style over time rather than repeat itself.
Each morning, the agent:
  1. Pulls current weather conditions for a fixed location.
  1. Reads its own history of the last five days — what themes and styles it already used.
  1. Asks Amazon Bedrock (Nova Lite) to write a title, a short poem, an image-generation prompt, and a one-sentence "style note" describing how today should evolve from what came before.
  1. Asks Bedrock again (Stability's Stable Image Core model) to paint the postcard from that prompt.
  1. Publishes the image and an updated gallery page to S3, and logs the day's record to DynamoDB so tomorrow's run has something to build on.
The gallery is a single static page, newest postcard first, so you can scroll back through the agent's whole run and watch its style drift over time.

How I built it

I started from the architecture, not the code: an always-on agent, by definition, needs a trigger that doesn't depend on anyone opening anything, so Amazon EventBridge Scheduler driving an AWS Lambda function was the obvious backbone — push-based, scales to zero, and free-tier friendly.
The more interesting decision was how to make "improves its style over time" real instead of cosmetic. It would have been easy to fake it with a static prompt, but instead every run reads the last five DynamoDB records and feeds their  style_note  and  theme  fields back into the text-generation prompt, explicitly instructing the model to push the style in a new direction while keeping a recognizable throughline. It's a genuine (if simple) feedback loop: today's output shapes tomorrow's instructions.
The biggest challenge wasn't code, it was model access. I'd planned to use Amazon Nova Canvas for image generation, since it's Amazon's own text-to-image Nova model and the most natural fit for the challenge's "Nova models" prompt. But once I actually tried invoking it, Bedrock returned an access error: Nova Canvas is marked  LEGACY  in this account's catalog, and accounts without 30 days of prior usage are blocked from on-demand access. Rather than burn a chunk of the weekend requesting an exception, I checked the Bedrock catalog across regions and found  stability.stable-image-core-v1:1  — a fully active text-to-image model — available in  us-west-2 . I moved the whole stack there, kept Nova Lite for all the text generation (title, poem, prompt-writing, style notes), and used Stability for images. It's a good example of designing around what a real AWS account actually has access to, rather than the ideal case — the kind of thing you only discover by actually invoking the model, not by reading the docs.
Everything else came together quickly once that was settled: a single Lambda function (Python, boto3, no extra dependencies — even the weather lookup uses the standard library's  urllib  against Open-Meteo's free, keyless API) and a CloudFormation template defining the S3 bucket, DynamoDB table, IAM roles, Lambda function, and EventBridge schedule as one deployable stack.

AWS services used and architecture

  • Amazon Bedrock —  amazon.nova-lite-v1:0  for poem/title/prompt/style-note generation,  stability.stable-image-core-v1:1  for the postcard image.
  • AWS Lambda — the orchestrator; one function, triggered daily, calls Bedrock twice, writes to S3 and DynamoDB.
  • Amazon EventBridge Scheduler — daily cron trigger ( cron(0 12 * * ? *) ), no polling, no always-on compute.
  • Amazon S3 — hosts the public static gallery site and the generated postcard images.
  • Amazon DynamoDB — stores each day's record (theme, style note, poem, image key) as the memory the style-evolution loop reads from.
  • AWS IAM / CloudFormation — least-privilege execution role and a single template deploying the whole stack reproducibly.
EventBridge Scheduler (daily cron)
|
v
AWS Lambda ----> Open-Meteo (weather, no auth)
|
|----> Bedrock: amazon.nova-lite-v1:0 (poem, title, image prompt, style note)
|----> Bedrock: stability.stable-image-core-v1:1 (postcard image)
|----> DynamoDB (history: date, theme, style_note, poem, image_key)
|----> S3 (postcard image + regenerated index.html gallery)

What I learned

Model catalog access is a real design constraint, not a footnote — the model you planned around on paper (Nova Canvas, in my case) may simply not be available to a given account, and the fix is to actually probe the account's Bedrock catalog and region availability before committing to an architecture, not after. I also came away with a much better appreciation for how little infrastructure an "always-on agent" actually needs: no queue, no orchestration framework, no persistent compute — a scheduled Lambda and a DynamoDB table are enough to build something with real memory and a real feedback loop. And treating the history table as the agent's "memory of its own past work" rather than just a log turned out to be the difference between a one-shot generator and something that actually behaves like it's evolving.

Try it / 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