AWS Builder Center
Weekend Showcase Challenge: FocusForge

Weekend Showcase Challenge: FocusForge

A focus timer where your tasks are raw iron and finished sessions forge them into collectables, so quitting early ruins the piece. This weekend it gained an AI that turns a brain-dump into an ordered plan for your day, and a cooldown you actually control. Built on AWS SAM with Lambda, DynamoDB, Cognito, and Amazon Nova Micro on Bedrock.

Staff Site Reliability Engineer

Vision and what it does

Most focus timers ask you to sit still and watch a number go down. FocusForge asks you to make something.
The problem is that timers are good at counting and bad at making you want to begin. A checkmark is a weak reward. Nothing is left behind when the bell rings, so there's very little pulling you into the next session.
Here's how it works instead. Your tasks are raw iron. You put one on the anvil, choose how long to heat it, and while you work the metal glows through real forge colours, from dull red up through orange and yellow to white heat, with a pyrometer gauge climbing beside it. Finish, and the piece is forged into a collectable whose rarity depends on how much time you committed. Quit early and you quench it: the piece is ruined, the streak resets. It's the only penalty in the app, and it only ever applies to a session you chose to start.
Over time you get a shelf that fills up with things you made, which turns out to be a much better reason to start than an empty checkbox.
I built the first version for the Full Stack Challenge the other week. It worked, it was deployed, and it had a short list of things I'd run out of time for. This week was the chance to go back and fix the two that actually bothered me.

The thing that was missing

The timer was never the hard part. Deciding what to work on was.
You sit down with eight things in your head and spend fifteen minutes choosing instead of starting. So the Forge Master, the AI apprentice living in the sidebar, learned a new trick. You dump everything on your mind into a box, unpunctuated and unordered, exactly as it arrives:
study for calc 2 test, email advisor, fix the login bug, read a NYT article
It hands back an ordered plan. Deepest work first, while your attention is still fresh. Quick wins batched between the heavy pieces. Each step sized to a real session length with a one-line reason for why it sits where it does. One click turns the whole thing into a pre-sized queue.
That's it. No new screen, no configuration. It just answers the question that was stopping you.
It runs on Amazon Nova Micro, and the thing I didn't expect is how well a small cheap model handles this. Give it four scrappy fragments and it comes back with sensible ordering and a reason for each one. The heavy study session goes first, the two minute email gets tucked in behind it.

FocusForge Plan My Day Dump

Plan My Day


FocusForge Plan My Day Converted

Plan My Day Converted


The thing that was rude

The old build force-started a five-minute break the second a session ended. I'd built the exact behaviour I dislike in other apps: being told when to rest.
So now the piece finishes and the app waits. You pick a cooldown length, skip straight back to the forge, or turn on auto-start if you actually liked it that way. You can also take a cooldown from a standing start, without forging anything first, because sometimes you just want a timed rest.
The part I enjoyed building most: during a cooldown the entire visual runs in reverse. The gauge drains from white heat back down through orange and red to dark. The workpiece cools with it. The hammer stops and the sparks die, because you're resting, not working.
My first attempt at that was a separate blue "cooling" meter filling up from the cold end, and it looked as wrong as it sounds. Metal loses its white heat first. Once I stopped inventing a new visual language and just ran the existing heat ramp backwards, it took one variable and looked right immediately. The simplest version was also the physically honest one.

Revamped Cooldown

Cooldown Revamped


How I built it

The habit that made this week possible is a running notes file I keep in the repo. Every session ends by writing down what actually works, what's broken, and anything that cost me real time. Weeks later I didn't have to remember why a decision was made or rediscover a bug I'd already solved, and the list of things I fixed this week came straight out of it. I'd recommend it to anyone who builds in short bursts and then has to pick the thread back up.
I also build alongside Kiro, which is good at surfacing options I didn't know existed. The decisions stayed mine, but having something that could research quickly kept me moving.
Everything lives in a single AWS SAM template, which means one command builds it and one command removes it completely. That mattered more to me than architectural elegance. I tore this stack down after the last challenge and stood it back up for this one, and I wanted to be certain nothing was quietly left running.
The decision I'm most glad about is one nobody will see. The planning feature didn't get its own endpoint. The existing one already had the Bedrock client, the guardrail, the rate limiter, the input sanitising and the output validation, so a second route would have meant duplicating all of it. Instead the handler looks at the request: if there's a brain-dump, plan it, and if not, behave exactly as before. The new feature is genuinely additive, and the original flow it grew out of is untouched.

AWS services and architecture

There are two paths through it. Anything you look at comes from S3 by way of CloudFront over HTTPS. Anything that touches your data goes through API Gateway, which checks your Cognito token before it will talk to anything else, and then on to one of five Lambda functions. Those read and write DynamoDB, and call Bedrock when the Forge Master is involved.
Amazon Cognito handles auth, with public signup deliberately switched off. API Gateway validates a JWT on every call. Five Lambda functions on arm64 do the work, each with an IAM role scoped to only the DynamoDB actions it genuinely needs. DynamoDB is a single on-demand table that scales to zero when I'm not using it. Amazon Bedrock, running Amazon Nova Micro behind a Guardrail, powers both the task sizing and the new planning feature. CloudFront and S3 serve the frontend over HTTPS with security headers.
The whole thing runs inside the free tier, and Bedrock costs fractions of a cent a day. Some of that is having one user, but the choices are the right ones regardless: on demand tables that scale to zero, arm64 functions, and the cheapest model that could do the job.

What I learned across the summer

I picked one project and returned to it rather than starting something new, so most of what I learned came from living with the same codebase.
Coming back to a finished project is a different skill from building one. Everything I shipped this week was already on a list I'd written for myself weeks ago. The work wasn't discovering what to do, it was resisting the urge to add something new and shiny instead of fixing the things I'd already identified as wrong.
A passing test can lie to you. I wrote a check for the new planning endpoint and it failed immediately, not on the feature but on a bug in my own test helper. Fixing that turned up an older test that had been asserting a hardcoded number, which meant it had been passing no matter what the code actually did. That one stung. Tests now derive what they expect from the source instead of repeating it.
Open a second browser. The bug that cost me the most time was a layout problem that existed in Chrome and simply didn't exist in Firefox. The sidebar grew two scrollbars in one and looked perfect in the other. I had been building and checking in a single browser the whole time, so it was invisible to me until I happened to look somewhere else.

What's still rough

A few things I haven't built yet. There's no password reset in the interface, mostly because I didn't want to open a hastily built MVP up to the whole internet. If the API goes down the app doesn't handle it gracefully. Deploys are still me typing a command. The checks I run against the live stack are smoke scripts rather than a proper browser test suite, and nothing runs in CI.
And realistically, I'm the only person who has used this properly, which means the next interesting bugs are the ones someone else will find.

Link to the repo

Everything is in there: the SAM template that defines the whole stack, the Lambda handlers, and the  just  recipes that build and tear it down. I'm not keeping a public instance running, so there's no demo link to click. If you want to see it move, the repo will stand it up for you in two commands.

Tagging a builder who inspired me

My favourite build of the season was Oluwatobisimi Ilori's Opportunity Scout. It wakes itself up every morning, hunts for hackathons and scholarships, scores each one against your profile, and has a briefing in your inbox before you pick up your phone. That's the kind of tool I wish I had as a student!

Final Thoughts

Built with React, TypeScript, AWS SAM, and Kiro. If you clone it and something breaks, or the forge metaphor stops making sense somewhere, I'd genuinely like to hear about it.
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