AWS Builder Center
Weekend Showcase Challenge: Oshiire Dungeon

Weekend Showcase Challenge: Oshiire Dungeon

Oshiire Dungeon is a home storage tracker built on AWS. After launching a text-only MVP, I added image recognition using Amazon Bedrock (Nova Lite) to auto-fill item names from photos. Testing with my family revealed UX flaws: low-contrast text made suggestions invisible, and requiring an extra click to apply them created friction. I updated the flow so photos instantly populate the name field. Users can edit it before hitting "Record it," ensuring full control with zero database risk.

Project Manager/General Manager
Oshiire Dungeon is a storage tracker I shipped a week ago for the AWS Full Stack Challenge. Every box or shelf becomes a chest in a dungeon, and you can seal loot in it without knowing what's inside yet.
I built this app with MVP discipline in mind. Staying an MVP meant cutting a feature on purpose before launch. This article is about adding that feature back. Adding it wasn't the end of the story either. A family member tried the app, found problems, and I ended up fixing it in two more rounds.
The article covers three things:
  1. Adding back the feature the MVP deliberately skipped
  1. Two rounds of fixes after a family member actually used it

Vision and what it does

The premise hasn't changed. You aren't exploring the dungeon, you're building it. An oshiire (the built-in closet in most Japanese homes) fills up twice a year at koromogae, the seasonal wardrobe rotation. A year passes before you need any of it again, so you forget which box holds what.
That's still the base this weekend's build sits on. What changed is what happens when you log an item.
The original MVP deliberately left out auto-categorizing a chest's contents from a photo with Bedrock. I explained why in the original article: a feature that depends on classification accuracy is risky to put at the center of a deadline build, because a wrong guess means rework. So the MVP stayed text-only. Looking back, that was exactly the kind of scope cut an MVP is supposed to make.
That's part two of the story. A week later, with no deadline, I added the feature back on top of the MVP. It didn't work the first time I added it, though. Part three is that a family member actually used it, and that pushed me through two more rounds of changes.
The app now looks at the photo you attach to an item and fills in the item's name field with a suggestion. Not the category field, and not silently. Once a suggestion comes in, a box appears under the field:
Name auto-filled from photo: computer mouse — edit it if it's wrong, or just record it.
You can overwrite it, or just press RECORD IT. Nothing gets written to the database until you press that button, so a wrong guess doesn't cost anything. It's just a value sitting in a text field, not something written behind your back.
The first version filled the category field instead of the name field, and you had to press a separate "Use" button to confirm it. I checked the real Bedrock price at that point. It came out to well under a tenth of a cent per photo. That's cheap enough that the extra confirmation step wasn't worth keeping, so I switched to filling the name field, the one field the app actually requires. Now attaching a photo alone is enough to record something.




How I built it

Photo uploads already went straight to S3 with a presigned URL, so photos never touch Lambda. That was a cost and payload-size decision from the original MVP. Getting a suggestion needs the opposite: the bytes have to reach Bedrock somehow. Instead of breaking the "photos never touch Lambda" rule on every upload, I moved the upload earlier. A photo now uploads the moment you pick it, not when you submit the form, so a suggestion can come back before you submit. Lambda then reads that one object back from S3 to classify it.
That timing change is where the bug was hiding. I bump a request ID every time you pick a photo, so an old suggestion can't overwrite a newer one. Clearing the file selection also bumps that ID. But the in-flight request's own cleanup only fires for the ID it started with, so it never ran. The "fetching a suggestion" flag stayed stuck at  true , and the submit button stayed disabled. Manual testing never caught it. A code review right after deploying did, using the same "read the diff against its own edge cases" approach the original MVP's UX week argued for. The fix and redeploy took about as long as writing this sentence.
I wrote tests for the two functions that carry the actual logic before I wrote the implementation. One checks that a requested photo key actually belongs to the caller's own household. The key comes from the client, so without this check, one household could peek into another household's photo bucket. The other cleans up the model's raw reply: strip quotes, keep only the first line, and reject anything over 60 characters or equal to  unknown , returning either a usable string or  null . Both ran under Vitest before I wired them into the Lambda that actually calls S3 and Bedrock.
I deployed, tested it end to end against the real stack, and it worked. Then a family member tried it and told me nothing happened. It had happened, every time. The suggestion was rendering correctly, but it was styled exactly like a plain hint line elsewhere on the same form, in the same low-contrast, muted color. A feature that fires but gets ignored fails just as hard as one that never fires. No CloudWatch log or Vitest assertion catches that. Only a second pair of eyes on the actual screen does. It was the same lesson the original MVP's UX week already paid for, showing up again in a different shape.
That fix turned the suggestion into a bordered callout instead of hint text, but it was still one click short of useful. The same family member, now able to actually see the suggestion, told me requiring a click was just an annoying extra step. I checked the real Bedrock price for  amazon.nova-lite-v1:0  again, and at realistic photo sizes it came to about $0.0001 per photo, checked against the actual pricing table. At that price, I decided it was fine to just go ahead and apply the suggestion directly. Writing it straight into the name field, still editable and not submitted until you press RECORD IT, let me remove that one extra step. Having a family member who doesn't know how the app works actually use it is what pushed the app to a better place.

AWS services used and architecture

The suggestion path sits on top of the existing single-Lambda, single-table design instead of adding a new service. There's one new route,  POST /items/suggest-category , handled by the same function that already routes every other request. (The route name is left over from the first version. The field it fills moved to name after the route was already built, and renaming the endpoint just for naming preference wasn't worth another deploy.)

Here's what it does. It reads the object from S3 with  s3:GetObject , a new permission, since this function previously only had  s3:PutObject  for issuing presigned uploads. Then it calls Bedrock's Converse API with  amazon.nova-lite-v1:0 , sending the image bytes and a prompt asking for a short label. The IAM policy scopes  bedrock:InvokeModel  to that one model's foundation-model ARN, no wildcard. It's a base model ID callable on demand, so no inference profile is needed either.
I didn't guess at the model. I confirmed it was actually callable with  aws bedrock list-foundation-models  and a real  converse  call against the target account and region, including a throwaway test with an image, before writing a line of application code.
Here's the Nova Lite pricing (us-east-1) as of August 2026. It may have changed by the time you read this.
Item
Price
Input
$0.06 / 1M tokens
Output
$0.24 / 1M tokens
With  maxTokens: 20 , one classification call costs under a cent regardless of photo size. Everything else is untouched: Cognito for auth, API Gateway's native JWT authorizer, a single DynamoDB table, and CloudFront serving both the SPA and photo reads from the same domain.

What I learned across the summer

Every build I made this summer kept coming back to the same theme: whether a Bedrock model is available isn't something you can assume, it's something you check. An earlier build hit Nova Canvas locked as LEGACY and Titan retired with no working replacement, and I only found out by trying to invoke them. This time, I invoked the model from the command line, first with text and then with a real image, before writing a line of TypeScript, from the same account and region Lambda would eventually run in. That habit, formed from an earlier failure, is what kept this build from repeating it.
The second theme: a feature you cut under a deadline is often still the right feature, just not the right timing. Cutting it wasn't a loss, it was sequencing. Even the shape it should come back in wasn't fixed in advance. This feature went through three shapes in one weekend: a suggestion behind a click, a visible suggestion, and a direct autofill once I knew the real cost of a wrong guess was a fraction of a cent going into an editable text field. None of those changes were predictable ahead of time. Each one only became clear after a family member actually used the previous version. If there's a next step, it's a nightly batch pass that offers the same fill-in-and-edit flow for items that never got a name from a photo, not just at the moment you pick one. A pile of last season's unnamed chests is a different problem from a fresh one.
The third theme showed up again this weekend: "it works" and "it's usable" are different claims, and only the second one matters. This build passed every automated check I threw at it: Vitest,  tsc ,  cdk synth , a live Lambda invocation against real S3 objects. The real gap only showed up after that, when a family member found it.
One more note: I didn't benchmark classification accuracy systematically. What I tried was a handful of photos and one family member's reaction. I haven't tested accuracy at scale or across multiple users.

Link to app and repo

Tag a builder who inspired me

Tagging @Lewis Sawe. The Museum That Grows is the build that showed me the idea of leaving something running and reading its output as a set instead of one run at a time. It clicked for a lot of builders this summer, me included.
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