
Full Stack Challenge: FocusForge
Gamified productivity app with a blacksmithing theme; tasks become forged collectables, quitting ruins the piece. Built using Kiro on AWS SAM, DynamoDB, Cognito, and Bedrock.
Series: The Full [Stack] Challenge (1 article)
- 1Full Stack Challenge: FocusForge This article
Full Stack Challenge: FocusForge
A gamified productivity app with a blacksmithing theme. Tasks become forged collectables, and quitting early ruins the piece. Built on AWS SAM, DynamoDB, Cognito, and Bedrock.
Vision and What It Does
I wanted to build something that made focus feel rewarding, not just productive. FocusForge is a focus-session app themed around blacksmithing. Your tasks are raw iron, and each completed session forges them into collectable items of increasing rarity. If you quit early, the piece is ruined and your streak resets.
The random word was Anvil, and it ended up being a really natural fit. The whole experience grew around the forge metaphor: an anvil at the center of the screen, a heat gauge showing progress, a Smithy where your collection lives, and an AI "Forge Master" that looks at your task list and suggests how long each piece needs in the fire.
It's for anyone who struggles with staying focused (myself very much included). Pomodoro timers work, but they can feel a bit sterile. FocusForge tries to add a little something extra: a reason to want to finish. The reward isn't a checkmark. It's a piece sitting in your collection, with rarity that reflects the time you put in.
Full Stack Breakdown
This project followed the stages from the Builder Center series, which gave me a nice structure to work within:
- Pitch: The starting idea was "gamified focus timer with a blacksmithing theme." Having the anvil constraint made decisions easier because I could always ask "does this feel like a forge?"
- Prototype: I started with just the timer and reward loop in React with localStorage. No backend, no auth. Just: can you start a session, finish it, and feel something when the item appears?
- MVP: Then came the progression system: XP, ranks, badges, weekly challenges, rarity tiers gated on session duration, and loss aversion through ruined pieces. All pure functions, with 36 unit tests. Still running entirely in the browser at this point.
- UX: I added dark mode ("Forge") and light mode ("Daybreak"), built an automated contrast checker that caught two WCAG failures I wouldn't have noticed by eye, added an onboarding flow, and made sure empty states hinted at what was possible rather than showing a blank screen.
- Launch: Deployed everything as a single SAM stack to AWS. Cognito for auth, DynamoDB for data, API Gateway + Lambda for the API, Bedrock Nova Micro for the AI feature, and CloudFront + S3 for hosting. One
sam deleteremoves it all.
How I Built It
This was a 48-hour sprint, built alongside Kiro (an AI coding assistant). Kiro was helpful for surfacing options I didn't know about. When I asked about prompt injection defenses it pointed me to Bedrock Guardrails, and when I asked about credential practices it found relevant docs. I still made the decisions, but having something that could research quickly helped me keep moving.
Some of the decisions that shaped the project:
- SAM over CDK or Terraform. I wanted one file where I could see everything that exists in AWS.
template.yamlis around 300 lines, nothing hidden behind abstractions, and teardown is one command. For a solo project on a tight deadline, that felt right.
- Three.js was tried and removed. I got excited about a 3D anvil animation, but hand-built low-poly geometry didn't look good. The reference I was inspired by used a professionally modelled asset. The technology wasn't what made it impressive, the art was. I replaced it with inline SVG and
feTurbulencefor a heat shimmer effect that I'm happier with.
- Rank decay was considered and rejected. Ruining a piece happens because you chose to quit a session you started, and that feels like a fair consequence. But rank decay punishes you for having a busy week or getting sick. That's the pattern that made me quit Duolingo. So rank never decays here. Weekly challenges and collection goals provide renewable motivation instead.
- Rewards scale with effort. In the first version, a 15-minute and 60-minute session paid identically, which didn't feel right. Now rarity is gated on duration, XP has a multiplier, and there's a test confirming that one 60-minute session earns more than four 15-minute ones.
- The Forge Master AI. Adding something like "Study for calc 2 test" came back with "45m, complex math review." Then "Save a bookmark" got "5m, single quick action." It's small, but having something acknowledge what the task involves before you start makes the timer feel less arbitrary.
- Accessibility. I added automated contrast checking early and it caught two color tokens below WCAG 4.5:1 that looked fine to my eyes. I also added axe-core, which runs against the static build and catches structural HTML issues. Neither is a substitute for testing with real assistive technology, but they're a starting point that runs in seconds.
AWS Services and Architecture
Everything lives in a single SAM stack.
- Amazon Cognito: Handles authentication. I went with admin-only signup, so I create users via CLI. It's a personal app, so this keeps things simple. Every API call requires a valid JWT.
- Amazon API Gateway (HTTP API): Routes requests to Lambda functions. JWT authorizer validates tokens. Throttled at 50 req/s.
- AWS Lambda (5 functions): One for each CRUD operation on tasks, plus the Forge Master. Each function has its own IAM role scoped to the DynamoDB permissions it actually uses. Running on arm64.
- Amazon DynamoDB: Single table, on-demand billing, scales to zero when idle. Partition key is user ID. Point-in-time recovery enabled.
- Amazon Bedrock (Nova Micro): Powers the Forge Master. Reads task titles and suggests session durations. Nova Micro is the cheapest model on Bedrock ($0.035/1M input tokens). Rate-limited to 5 calls per day per user, with a Bedrock Guardrail for prompt injection detection.
- Amazon CloudFront: Serves the frontend over HTTPS with Origin Access Control. Response headers policy adds HSTS, CSP, and X-Frame-Options.
- Amazon S3: Frontend build artifacts. All public access blocked.
- On security: I went a bit overboard here relative to what the app actually needs. It's a single-user focus timer. But I wanted to learn how to do things like input validation, prompt injection defense, output schema validation, and managed guardrails properly. Whether that's over-engineering or building good habits, I'm not sure, but I learned a lot from it and I'm glad I did it.
- On cost: At my usage level (just me, a few calls a day), the app costs effectively nothing. Most services are in the free tier and Bedrock is fractions of a penny. That would change with more users, but for a personal tool it means I can leave it running without worrying about it.
What I Learned
- Deploying early made everything easier. Building a
just bootstraptojust deploy-frontendflow took real effort, but it meant I could catch mismatches between local and deployed behavior throughout the build rather than all at the end.
- Testing the wiring matters as much as testing the logic. I have 36 unit tests on the progression logic, and a few bash scripts that hit the live API to check things work end-to-end. The scripts aren't a proper test suite, but they're what caught the issues that actually mattered: wrong units, internal records leaking into the task list, CORS misconfiguration.
- LLM security has a lot to learn. Prompt injection, insecure output handling, model manipulation. There's a whole OWASP Top 10 for LLM apps now. I tried to layer the defenses (sanitize input, delimit user data, validate output, use a guardrail). I'm not sure if what I built is "enough," but the process of trying taught me a lot about how to think about it.
- Automated accessibility tools are a starting point. My contrast checker caught color issues I couldn't see. axe-core caught structural problems the contrast checker missed. But they only test what can be tested against static HTML. They can't tell me how it feels to navigate with a screen reader. They're a floor, not a ceiling.
- Loss aversion is delicate. Punishing someone for missing a day feel unfair. Punishing someone for quitting something they chose to start might feel motivating. I think FocusForge gets this roughly right (consequences only apply inside sessions you've begun), but honestly I haven't used it long enough to know how the ruined-piece mechanic feels after a month.
- Most of what I know about LLM security I learned during this project. I didn't start knowing about Bedrock Guardrails or the OWASP LLM Top 10. It all came from asking questions and reading docs while building. I'm not claiming expertise. Just that 48 hours of curiosity-driven building taught me things I'll carry forward.
What's Still Rough
There are things I'd want to improve if I keep working on this:
- No forgot-password flow. Recovery is CLI-only right now due to local testing and not looking to scale.
- No offline support. If the API is down, the app doesn't handle it gracefully.
- My live testing is bash scripts, not an automated suite.
- I planned a canvas-based forge visualization that I never got to.
- The sidebar gets long on smaller screens.
- Deploys are manual, no CI/CD.
- I haven't done real user testing beyond using it myself.
It's a 48-hour project that works end-to-end, and I'm happy with what I learned building it. There's plenty more I'd like to do, and the foundation feels good enough to keep going.
Link to App and Repository
- Demo video: https://youtu.be/mA1-BWtS0jI
- Source code: https://github.com/cShirley14/FocusForge
Built with React, TypeScript, AWS SAM, and Kiro. Deployed in a single CloudFormation stack.
Series: The Full [Stack] Challenge (1 article)
- 1Full Stack Challenge: FocusForge This article
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article