
Weekend Creative Challenge: Cloud Bard
A bard turns any AWS service, your start date, or a topic into a short, narrated piece of cloud folklore, grounded in real facts from a live web search, complete with a quiz and a shareable illustrated lore card.
Every builder has an origin story nobody ever asked for: the first service you touched, the outage that taught you what IAM actually does, the weekend you finally understood VPCs. Those stories usually die in a Slack thread. I wanted to give them a stage, so I built Cloud Bard. Tell it an AWS service, your start date, or a topic, and a bard turns it into a short, narrated piece of cloud folklore, grounded in real facts pulled from a live web search, not made up.
Vision and what the app does
Type a service (S3), a date ("the day I started at AWS"), a topic, or just hit Surprise Me. Cloud Bard:

- Decides, agentically, whether it needs to search the web for real facts before it starts writing.
- Weaves whatever it finds into a short "cloud folklore" tale, a chapter with a title, a narrative voice, and a moral.
- Narrates the tale aloud in a bard's voice.
- Generates a short comprehension quiz from the tale.
- Renders a shareable illustrated lore card for it.
- Saves it to the Cloud Codex, a communal, browsable archive of every tale every builder has generated.
- Stamps it into your Builder Passport, a personal collection of which services you've collected tales for.
- Offers Crossover Lore: finds the closest thematic match between your tale and someone else's, via real vector similarity search, and writes a short blurb connecting the two.
- Shows Trending This Weekend, live pills of which services are getting the most tales right now, across every builder using the app.

The point isn't just "AI writes a story." It's that the story is yours, grounded in a real fact about a real
service, tied to your own AWS timeline, and dropped into a growing shared world other builders are adding to at the same time.
How I built it
The design choice I cared most about: Cloud Bard had to be a genuine agentic pipeline, not a single prompt wearing a costume. Concretely, that meant an actual Strands Agents SDK Agent deciding, at inference time, whether to call a live web search tool before writing, not a hardcoded "always search, then generate" script.
That decision cost me a full afternoon. Amazon Nova Lite, the obvious cheap, fast choice for this, reproducibly failed the moment I gave it real tool choice: ModelStreamErrorException: Model produced invalid sequence as part of ToolUse, on every retry, at temperature 0. I confirmed it wasn't my code (direct tool calls worked fine, it was specifically Nova driving the decision to call a tool that broke) and confirmed it wasn't just "Lite is weak" (Nova Pro hit the identical error). For a while I shipped a compromise: call the search tool directly and unconditionally, skip the agentic decision, and still call it "grounded." It worked, but it wasn't honest about what it was. I went back and re-tested against us.amazon.nova-2-lite-v1:0, a different model generation, not just a bigger version, and it drove the full tool choice loop cleanly, zero errors. That one swap turned Cloud Bard from an LLM call with a search step bolted on into a system that actually decides.
The second real obstacle: I picked Titan Image Generator v2 for the lore card art. Partway through the weekend, Amazon fully retired it, gone from the model catalog, InvokeModel returning "this model version has reached end of life." The natural fallback, Amazon Nova Canvas, turned out to be gated behind a legacy model inactivity block that no IAM change or access request could fix. I found a genuinely excellent replacement, Stability's Stable Image Ultra, on Bedrock, in us-west-2, but the AWS account I was deploying to had never completed its Marketplace subscription for third-party models, and adding a payment method wasn't an option I wanted to take mid-build. Rather than give up on real generated art, I had render-lore-card assume a narrowly-scoped cross-account IAM role in a second AWS account that already had a working subscription, call Bedrock with those temporary credentials, and hand the result back. Cross-account access as an escape hatch for a billing gap, not a security workaround: the assumed role can do exactly one thing, invoke exactly one model.
The bug that taught me the most, though, was invisible to every test I wrote. Every one of Cloud Bard's custom Lambda resolvers quietly read an empty request in production, while unit tests and direct CLI invokes both passed, because Amplify Gen 2's real AppSync resolver event wraps GraphQL arguments under event.arguments, not flat on event, and both my mocks and my CLI test payloads happened to use the flat shape. I only found it by testing the actual deployed app in a real browser. It's the reason every request in the app was silently failing before I caught it, and it's the reason I now trust "does it work in a browser against the real deployment" over "do the tests pass" as the real bar for done.
AWS services and architecture overview
Type a request in the browser, and it flows through a real agentic pipeline:
- Frontend (Next.js on AWS Amplify Hosting) sends the request to AWS AppSync (GraphQL API).
- bard-agent (AWS Lambda) builds a Strands Agent, which decides whether to call Amazon Bedrock AgentCore Gateway's web search tool, then generates the tale and quiz via Amazon Bedrock (Nova 2 Lite), checked by Amazon Bedrock Guardrails.
- narrate (Lambda) calls Amazon Polly and stores the narration audio in Amazon S3.
- render-lore-card (Lambda) assumes a cross-account IAM role to call Amazon Bedrock (Stability Stable Image Ultra) and stores the image in S3.
- save-tale, browse-codex, and find-crossover (Lambda) read and write Amazon DynamoDB, including a native vector search over tale embeddings for crossover matching.
- trending-counts (Lambda) updates live per-service counters in DynamoDB.
Everything runs serverless, on AWS Free Tier eligible services where available.
What I learned
An agent's tool choice reasoning is a property of the specific model generation, not the model family. I nearly shipped a fake-agentic version of this app because I generalized one bad result ("Nova can't do tool choice") from one generation, instead of re-testing against the newest one available. That's a mistake I won't make again.
I also learned not to treat a chosen foundation model as a stable dependency. Between the Titan retirement and the Nova Canvas access gate, I hit two "the model I picked no longer works" walls in one weekend, and the fix both times was the same instinct: check the live model catalog again, don't trust what a spec written two days ago assumed.
And the biggest one: automated tests validate your assumptions, not reality. The empty request bug survived a full test suite because my tests and my bug shared the same wrong assumption about the event shape. A five minute real browser session against the real deployment caught what hours of "green" test runs didn't.
Go build a service into a legend. I'd love to know what Cloud Bard writes for you.

Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article