
Weekend Creative Challenge: Daybreak
A small app that asks how you're arriving today and gives back one thing to read: a verse or a line, a reflection written for what you actually said, a card drawn in the browser, and a voice reading it to you.
Some mornings I know exactly how I'm arriving. Most mornings I don't, and I scroll instead.
Daybreak asks one question — how are you arriving today? — and gives back one thing to read. A verse or a line, a short reflection written for what you actually said, a card you can keep, and a voice reading it to you if you'd rather listen than look.
You can have it grounded in scripture or not. That's a single toggle, and it's the only setting in the app. In Rooted mode the verse is looked up from the corpus; in Plain mode the line is written by the model.

Vision and what the app does
The creative output is three things at once: words (a reflection written for your morning), an image (a card, drawn procedurally, downloadable at 1080×1080 or 1080×1920), and sound (the whole thing read aloud at a deliberate, unhurried pace).
You type however it comes — "big presentation today and I keep second-guessing myself", "starting a new job on Monday and I'm not sure I'm ready" — and Daybreak reads that, chooses something, and writes around it. It isn't a Bible app and it isn't a journal. Nothing is stored. It's one quiet thing, once a day.

The design constraint I set myself was calm. No streaks, no notifications, no history, no gamification. An app about starting the day gently shouldn't be trying to increase engagement.
How I built it
Scripture is data, never output
The first decision shaped everything else: a language model never writes, completes, or paraphrases a verse. It may point at one; it never produces one.
That matters because models misquote scripture with total confidence, and people memorise and share what an app hands them. So the app carries the entire World English Bible — all 31,095 verses, public domain — bundled as JSON. Every verse displayed is a lookup. When the model is allowed to choose, it returns only a reference, which the code resolves against the corpus and rejects if it doesn't exist. That resolution step doubles as a hallucination check: an invented reference simply fails to resolve.
I nearly shipped a curated set of about a hundred verses instead of the whole book. That was the wrong instinct — the full WEB text is roughly 4.5 MB, which is nothing next to Lambda's 50 MB limit. There was never a scale reason to trim it, and carrying all of it unlocked the feature I like most: tap the reference and read the passage around it.
The rule I copied where it didn't belong
That rule was right for scripture. I then applied it to the Plain-mode lines as well — where none of the reasoning holds, because a line isn't scripture and there is nothing to misquote — and it produced the one bug I couldn't design around.
Someone wrote "I'm feeling very happy and joyful today because I got a new job." The reflection was written from their words and read perfectly. The card line, looked up from a curated file, said "The road is empty because it is early, not because you are lost." The classifier had read "new job" as starting something and pulled from the apprehensive end of that bucket. A person celebrating had been handed reassurance for feeling lost.
So in Plain mode the encouraging line is now generated by the model. Nova Lite writes it in the same call as the reflection, which means it answers what the person actually wrote instead of being drawn from a bucket. The curated file survives only as a fallback — for validation failures, and for the distress path, which is the one place an improvised line is genuinely risky.
Scripture is still never generated. In Rooted mode the verse remains a byte-for-byte lookup from the corpus, exactly as before. The constraint was right where it mattered and wrong where I'd copied it out of habit.


What it knows versus what it hands you
Those are different problems, and conflating them is how this kind of app goes wrong.
The app knows every verse. But what it offers someone at six in the morning comes from a curated index — a map of mood to verse, which I assembled by searching the corpus for candidates and then reading every single one.
That reading took the longest hour of the build, and it was the most important. Semantic search for "anxious" cheerfully returns judgment passages and imprecatory psalms. They belong in the corpus. They are not what you hand someone who has just told you they're struggling. No amount of cosine similarity understands that distinction, which is precisely why it's a file I've read rather than a retrieval I trust.
The image model that wasn't there
I planned to generate the card backgrounds with Amazon Nova Canvas. It wasn't available to me — Nova Canvas is in Legacy, Titan Image is end-of-life, and the Stability models on offer are editing-only and need an input image. I confirmed it across two accounts. There was no text-to-image path.
So I drew them instead.
Each background is rendered in the browser on the same canvas that composites the card: a base gradient in the mood's palette, a large soft radial light, one structural motif per mood — drifting mist for anxious, bokeh for grateful, a diagonal shaft for starting something — then film grain and a vignette. Light position, angle and grain are seeded from hash(date + mood), so each mood keeps its identity while today isn't identical to last Tuesday.

It turned out better than generation would have been, and I want to be precise about why rather than making a virtue of necessity.
First, consistency. A daily calm app wants recognisability, not surprise. Image generation gives you a serene lake on one run and something faintly uncanny on the next, and the uncanny one is the one you'd have shipped to someone having a hard morning.
Second, and this is the real gain: contrast stopped being a repair job. Text over a generated background means sampling unpredictable pixels and hoping a scrim rescues legibility. Because I draw the pixels, I clamp the luminance of the text region and it's legible by construction. The contrast check is still there — but as an assertion that should never fire, rather than a mechanism I depend on.
It also deleted an entire round trip. No image API call, no S3 upload, no presigned URL. The card just appears.

The bug that mattered
I typed "Starting a new job on Monday and I'm not sure I'm ready" and got back a reflection about painful feelings, things I used to enjoy, and "I'm sorry you're experiencing it."
That's language for sustained low mood. I was nervous about a job.
The classifier was reading any expression of uncertainty as discouragement — collapsing anticipation into despair. They share vocabulary and they are not the same feeling, and getting them backwards means handing a condolence to someone who's just a bit keyed up. The fix was to define the moods against each other explicitly: starting something is forward-looking, discouraged requires evidence that something has already gone wrong.
There was a second tell I nearly missed. Every good response quoted the user's own words back — "as you prepare for your presentation", "your week went well". The bad one never mentioned the job at all. That was the signal the reflection was being written from the mood label alone rather than from what the person actually wrote.
The box I was told not to build
The safe design was fixed mood buttons. No free text, no risk of someone typing something genuinely dark into a devotional app.
I kept the text box, because being asked how are you arriving today? and then handed six buttons is not the same experience — the box is what makes it feel like something is listening. So I built the handling instead.
When the input carries real distress, a banner appears above the card: "You wrote something heavy, and it matters. This is only a small daily encouragement — if you're struggling, please reach out to someone you trust, or a professional." The reflection acknowledges the weight rather than brightening past it, and it doesn't promise outcomes.
Testing that path was the most important testing I did. Anyone can check the happy path.
AWS services and architecture
How it's triggered: entirely user-initiated and synchronous. The browser posts to a Lambda Function URL and holds the connection until the response returns.
Browser (static, no framework) │ POST { text, mode } ▼AWS Lambda (Function URL, Python 3.12) ├─ classify mood Bedrock Nova Lite ├─ look up verse web-bible.json ← deterministic, no model ├─ write line + reflection Bedrock Nova Lite ├─ write alt text Bedrock Nova Lite └─ synthesise audio Amazon Polly (neural, SSML) │ ├─ mp3 → Amazon S3 (private, presigned) └─ JSON → browser
Browser draws the background procedurally, composites the card,asserts contrast, exports at two sizes. No image round-trip.
Static site: Amazon S3 + CloudFront (OAC) · IaC: AWS SAM · us-east-1Service | Role |
|---|---|
Amazon Bedrock — Nova Lite | Mood classification, line, reflection, alt text |
Amazon Polly | Neural voice (Kajal), SSML-paced reading |
AWS Lambda | One Python function behind a Function URL |
Amazon S3 | Generated audio, static site |
Amazon CloudFront | HTTPS via Origin Access Control |
AWS SAM | One template.yaml deploys everything |
On Polly: the difference between a screen reader and a devotional is entirely pacing. The text goes out as SSML at 92% rate with a 900ms break between the verse and the reflection. Two lines of markup, and it changes the whole feel.
What I learned
A constraint improved the design. I lost the image model and got something better — consistent, instant, free, and legible by construction rather than by luck. I'd have generated the backgrounds if I could have, and the app would have been worse.
A good constraint copied into the wrong place becomes a bug. Scripture must be a lookup, because it can be misquoted. A one-line encouragement can't be, so it's generated — and applying the stricter rule where it wasn't needed is how someone celebrating a new job got told they weren't lost.
Contrast should be designed in, not repaired. Sampling an unpredictable background and adjusting a scrim is damage control. Controlling the pixels and clamping the luminance is just correct.
Classifiers flatten emotional nuance in ways that matter. Anticipation and despair share vocabulary. If you're routing on feeling, define your categories against each other, and test the boundaries rather than the centres.
Test the sad path first. The happy path always works. What matters is what your app says to someone who opens it on their worst morning — and you only find that out by typing it in yourself.
Link to app and repo
- Live app: https://d3f7xjgvqvtpm2.cloudfront.net/
Tell it how you're arriving. It's one small thing, and it's meant to stay that way.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article