
Full Stack Challenge: Oshiire Dungeon
Oshiire Dungeon is a storage tracker for the stuff you put away and forget. Every box or shelf becomes a chest in a dungeon. You seal loot in it, even if you do not know what is inside yet. Months later, search the dungeon instead of digging through your house. Built with React, Cognito, API Gateway, Lambda, DynamoDB, S3, and CloudFront on AWS. Made for the AWS Full Stack Challenge, using the word Dungeon.
Vision and What It Does
The premise is one sentence. You are not exploring the dungeon. You are building it.
Putting something away is not filing. It's sealing loot in a chest and hiding it from your future self. That future self is the adventurer, arriving months later with no map, no notes, and no memory of which chest holds what.
An oshiire is the deep built-in closet found in most Japanese homes. Twice a year, at the turn of the season, there's a ritual called koromogae: half of everything a household owns gets folded, boxed, and pushed into the back of it. A full year passes before any of it is needed again — long enough for the memory of which box, which shelf, to disappear completely.
Oshiire Dungeon sits in that year-long gap. When you put something away, you're a dungeon master sealing loot in a chest. Months later, when you need it, you're the adventurer coming back to a dungeon you built yourself. You built this dungeon, and you still can't beat it. That's not a stretched metaphor — it's literally what happens every koromogae.
It's built for anyone whose storage disappears once the door closes: an oshiire, a closet, a garage. In Japan that's close to every household, thanks to the seasonal rotation. But the underlying problem — putting something away so well you can no longer find it — isn't culturally specific at all.
Full Stack Breakdown
The Full Stack (Code.TV, presented by AWS Developers) followed eight teams turning an idea into a shipped product across five stages — pitch, prototype, MVP, UX, launch. This challenge compresses the same arc into 48 hours, with one constraint most concepts don't have: it has to start from a randomly drawn word.
Pitch — the constraint decided the concept
The word drawn from PartyRock's generator was "Dungeon." What came back first, though, was the generator's own suggestion: a gamified to-do list called QuestForge. The pitch-week lesson worth borrowing here was not to follow it. Take the word as the only binding constraint, and build the concept yourself. The moment storing something got reframed as a dungeon master sealing a chest, this stopped being a storage app.
Prototype-equivalent — deciding the concept was the prototype
There was no separate prototype week here, but the concept got tested on paper before any code. The core feature — sealing a chest without knowing what's inside it — got rewritten in plain text (and a few bad sketches) until it actually held together. Two decisions came out of that: location is a real entity, not free text, and both the photo and the notes are optional. Those two decisions shaped the data model and the API from there on.
MVP — the feature that got cut mattered more than the one that shipped
Before writing any code, there was a tempting idea: auto-categorize a chest's contents from a photo using Bedrock. Hand it a photo, get back "coat," "tools," "documents." It's the kind of feature that plays well in a demo, and it got seriously considered.
But a feature that depends on classification accuracy is a dangerous thing to put at the center of a deadline build. A wrong guess means rework, and rework threatens the one thing that's supposed to just work. The more interesting a feature like automatic tagging is, the more dangerous it is to start with under a deadline. So it got pushed to a "nice to have" tier, and the MVP stayed text-first: the user names the category, the user names the contents.
UX — working and usable turned out to be different things
Once the app worked end to end, the first thing back from a family member using it was: "I don't know what to type in any of these fields." The dungeon vocabulary — chest, loot, seal — was doing double duty as flavor and as the interface language, and it never once said what those words meant in a real house. More on the fix below, but this is exactly the kind of failure no amount of API testing finds. UX week's argument landed for real.
Launch — shipping wasn't the end
The challenge didn't stop at deployment. New bonus objectives kept appearing after launch: dark mode, and a 60-second demo video. Both fit the same idea launch week pushed — that shipping isn't the finish line, it's where you start polishing what you shipped. The dark mode toggle came out of a conversation about torches — lighting one, putting it out — which mapped onto the theme almost for free.
How You Built It
A failure wearing a success's face
Photo upload got wired up, and the first real test in a browser showed a broken image. The upload side — a direct PUT to S3 via a presigned URL — was returning 200 and was fine. The read side needed a closer look.
$ curl -s -D- -o /dev/null https://de90do7dcpeek.cloudfront.net/photos/<key>HTTP/2 200content-type: text/htmlx-cache: Error from cloudfrontLooking at the status code alone, this would have passed as fine. The image doesn't exist. The cause: CloudFront's
photos/* behavior forwards the matched path straight to S3, but the stored object key never carried that photos/ prefix. S3 behind Origin Access Control returns 403 for a missing object, and this app's CloudFront distribution rewrites 403 and 404 to index.html with a 200, to make client-side routing work. A broken image request came back wearing a successful response's clothes. The only tell was one header line, x-cache: Error from cloudfront . The fix: put photos/ in the object key itself, so the stored string is the public path. Nothing to assemble means nothing to get out of sync.Three failures, each passing the one before it
The Lambda bundle broke three times in a row, each time only after clearing the previous stage.
First, the handler lives in
api/ but CDK was bundling from infra/ .«PathNotUnderRoot» entryPath (.../api/src/index.ts) should be under projectRoot (.../infra)Second, esbuild tried to run from the repo root, where it wasn't installed.
npm error npx canceled due to missing packages and no YES option: ["esbuild@0.28.2"]Third was the expensive one. Bundled as ESM, it passed synth, passed deploy, and died only on the first real invocation.
ERROR Uncaught Exception{"errorType":"Error","errorMessage":"Dynamic require of \"node:https\" is not supported"}AWS SDK v3's CJS builds call
require() internally, and that doesn't survive being bundled into ESM output. Switching the output format to CJS fixed it. None of the three were logic bugs — all three were about where code lives and how it's packaged, and the third one stayed invisible until runtime.AWS Services / Architecture
The app is a static frontend backed by a serverless API. The browser authenticates against Cognito's Hosted UI and attaches the resulting JWT to every request. API Gateway validates that token with a native JWT authorizer, so there's no authorizer Lambda to write or debug. One Lambda function handles routing, resolving the caller's household from the token and reading and writing DynamoDB records. Photos take a separate path: the browser PUTs directly to S3 via a presigned URL the Lambda issues, and reads come back through the same CloudFront distribution as the app itself, under a
photos/* behavior — one domain, and no CORS needed on the read side.- Amazon S3 + CloudFront — static frontend hosting and delivery; a separate bucket for photos served from the same distribution
- Amazon Cognito — authentication, sign-up and sign-in handled entirely by the Hosted UI
- Amazon DynamoDB — single-table design; chests and items scoped by household ID
- AWS Lambda + Amazon API Gateway (HTTP API) — one function handles every route; JWT authorization is native, no separate authorizer function
- AWS CDK (TypeScript) — infrastructure as code; region is pinned rather than inherited from ambient CLI config
- Amazon Bedrock (under consideration) — auto-tagging item categories from a photo

What You Learned
The main lesson was UX week's argument, confirmed the hard way: a feature working correctly and an app being usable are not the same thing. No amount of API testing surfaces "I don't know what to type here" — that only shows up once a real person tries it, and it made clear how misleading "it works" can feel.
The second was about what failure looks like. CloudFront's SPA fallback quietly rewriting a broken image's 403 into a 200 of HTML was a reminder that a clear error is not something you're owed. The more layers of infrastructure stack up, the further a failure's surface can drift from its actual cause. That habit — doubting the obvious explanation — got reinforced more than once over these 48 hours.
Both curve balls got addressed along the way. Dark mode was built as CSS custom properties from the very first commit, with the toggle framed in-story as lighting or dousing a torch, dark as the default.


Link to App and Repo
- Live app: https://de90do7dcpeek.cloudfront.net
- Repository: https://github.com/sh-fk2/oshiire-dungeon
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article