Full Stack Challenge: Reliquary
A museum for the gaming moments you'd otherwise lose. You describe a memory; it comes back catalogued like an artifact. Built in 48 hours on AWS from the word RELIC — with Bedrock blocked account-wide twelve minutes in.
Full Stack Challenge: Reliquary
Live app: http://reliquary-web-232351199908.s3-website-us-east-1.amazonaws.com
Repository: https://github.com/mohitk-patwari/reliquary
Word drawn: RELIC
Vision and What It Does:
A reliquary is the vessel a relic is kept in.
That is the whole idea. Screenshots of the run that finally worked sit in a folder nobody opens again. The Discord message where you told someone about it scrolled away three years ago. The moment mattered. The artifact survived. Nothing ever gave it a frame.
Reliquary gives it one. You describe a moment from a game you played, in plain language, up to 600 characters. It comes back catalogued — titled, classified, inscribed, with an accession number — the way a museum treats an artifact rather than the way a leaderboard treats a score.
The design constraint that makes it work is a refusal. The app never congratulates you. Museum labels do not use exclamation marks or hype; they state what the object is, where it came from, and what it cost, and then they stop. Every line of generated text obeys that.
Give it this:
After 37 attempts I finally beat Malenia at 2am. My hands were shaking.
And it returns this:
VICTORY ARTIFACT 2018.418.9
The Cost of Victory
The visitor should note what is absent: no record survives ofthe 37 attempts that did not succeed, only of the one that did.
ORIGIN Recovered from a solo encounter with Malenia.PERIOD The small hoursCONDITION Intact; wear consistent with 37 attempts.
It is for anyone who has a folder of screenshots they will never look at again and cannot bring themselves to delete.
Full Stack Breakdown
Pitch. The generator handed me RELIC. My first instinct was the obvious one — a gaming memory app with a screenshot vault, an AI card generator, and a branching decision timeline. Three features, one comment, very tidy.
Prototype. Before writing any application code, I tested whether the core idea worked at all: could a museum-cataloguer voice turn "beat the boss on attempt 47" into something worth keeping? That question, not the architecture, was the real risk.
MVP. I cut two of the three features on day one. The screenshot vault and the branching timeline were two other applications wearing a trenchcoat. What shipped is a single flow: compose, view, collect. One input, one artifact, one shelf.
UX. Museum conservation rather than dungeon loot. Bone white and aged label stock against deep bronze, verdigris as the single accent, serif throughout. Light mode is a lit gallery; dark mode is the same gallery after closing — a genuinely different design, not an inverted one. There is no sign-up: a UUID generated in the browser identifies your collection. An artifact is the product; an account system in 48 hours is a liability.
Launch. Deployed on S3, backed by API Gateway and Lambda, public.
How You Built It
Twelve minutes into the build, a preflight check killed my architecture.
I ran Bedrock directly from the CLI before writing anything that depended on it:
us.anthropic.claude-sonnet-4-6 -> ValidationException: Operation not allowedus.anthropic.claude-haiku-4-5-... -> ValidationException: Operation not allowedus.amazon.nova-micro-v1:0 -> ValidationException: Operation not allowed
Three models, two families, with
AdministratorAccess attached. list-inference-profiles cheerfully returned twenty-five Claude profiles — but that API lists what exists in the region, not what your account may invoke. This was an account-level block, invisible from inside, reported as a validation error.I had lost ninety minutes to exactly this on a previous build, discovering it at hour four. This time I found it at minute twelve, and the architecture changed before a single line of the prompt pipeline existed.
So the fallback became the product.
lambda/fallback.py is a deterministic composer in about 500 lines of standard-library Python:- Signal extraction — regex passes pull attempt counts (
37 attempts,the third try,countless runs), durations, clock and word forms of time (2am,midnight,all night), and capitalised runs likely to be game or boss names, filtered against a stopword list soAfterandMyaren't mistaken for proper nouns.
- Register classification — the memory is scored against marker banks for TRIUMPH, DEFEAT, QUIET and SHARED, falling through to VAGUE. Outcome markers are checked before tone markers, because a victory achieved alongside a friend is still a victory. Company is a modifier, not a competing register. I found this by reading output: two shared triumphs were being catalogued as company memories and losing the thing that made them matter.
- Seeded selection —
random.Randomseeded fromhashlib.sha256(memory). Never Python's built-inhash(), which is salted per process and would hand you a different card on every Lambda invocation.
- Composition — hand-written template banks per register, with slot filling. A template is only eligible if every field it needs is present in the extracted context, so one requiring
{noun}never fires when no proper noun was found. Vague inputs degrade into genuinely vague labels rather than printing{noun}at the visitor.
The Bedrock path is still fully coded and shipped behind
BEDROCK_ENABLED . One environment variable and the app upgrades itself.Four other things broke, none of them findable by reading code.
Lambda Function URLs return 403 on this account with a provably correct resource policy — another invisible account-level restriction. API Gateway HTTP API replaced it in about thirty seconds with no Lambda change, since payload v2 has the same
requestContext.http.method shape.Three separate Windows path failures, all the same root cause. Git Bash rewrites any argument starting with
/ into a Windows path, so MSYS_NO_PATHCONV=1 is mandatory. But aws.exe is a native Windows binary that then cannot read the /c/... paths Bash correctly passed through — so fileb:// arguments need cygpath -w as well. And cygpath -w emits backslashes, which get mangled in turn, so the S3 bucket policy had to go inline as a quoted string with no file at all. Two of those fixes point in opposite directions.A deploy script's idempotency check silently failed open. It grepped for a quoted statement ID against JSON-escaped output, so it never matched and re-granted the permission every run. Same shape as the
|| true trap — a check that looks like it works and always says yes.crypto.randomUUID does not exist over plain HTTP. It requires a secure context. It worked perfectly in local dev and vanished the instant the app was served from an S3 website endpoint. The ID generator now falls back through crypto.getRandomValues and then to Math.random .I also ran three Claude Code agents in parallel — one on infrastructure, one on the frontend, one on the generator — coordinated by a
CONTRACT.md written by hand before any of them started, which none was permitted to modify. It worked partly by accident: every agent was told to read that file first, so when it didn't yet exist, all three stopped and refused rather than inventing three incompatible contracts. That refusal cost ten minutes. The alternative surfaces at hour four as an integration bug with no obvious cause.AWS Services and Architecture
Browser (React SPA) | \ | static assets \ JSON over HTTPS v v Amazon S3 API Gateway (HTTP API) website hosting | v AWS Lambda (Python 3.12) | +------------+------------+ | | fallback.py Amazon Bedrock (deterministic, PRIMARY) (integrated, flag-off) | v DynamoDB reliquary-cards PK id · GSI owner-index
- Amazon S3 — hosts the built SPA as a static website, with
index.htmlas the error document so client-side routes survive a refresh
- Amazon API Gateway — HTTP API, payload v2, fronting Lambda
- AWS Lambda — Python 3.12,
boto3only, no external dependencies
- Amazon DynamoDB —
reliquary-cards, on-demand; partition keyid, GSIowner-indexonownerId+createdAt
- Amazon Bedrock — integrated, shipped, currently flag-disabled
- IAM — least-privilege execution role scoped to that table, those Bedrock actions, and CloudWatch Logs
- Amazon CloudWatch Logs — Lambda logging
Every layer passes one shape, frozen in
CONTRACT.md before any code was written. It includes a source field, always present and always honest — "bedrock" or "fallback" — and the card displays it in the credit line. If a machine wrote the label, the label says so.What I Learned
Test the dependency before you build on it. One CLI call at minute zero is worth ninety minutes at hour four. This is the single habit that saved this build.
A correct config that still fails means look upward. SCPs, account activation state and organization controls are invisible from inside an account and produce errors describing the wrong problem. Two failed attempts on a verifiably correct config is the signal to change approach, not to try a third time.
AWS error messages misdirect on permissions.
ValidationException for an account-level block. 403 Forbidden with no hint a restriction exists. MalformedPolicy when the file was never read at all. Read them as something refused this, not as literal descriptions.Have a no-dependency fallback for anything AI-shaped. Losing Bedrock at hour four could have killed this submission. It didn't, because the creative work turned out to be doable in standard-library Python — and the result is more interesting than a prompt would have been. When the interesting part of your project is one API call to a hosted model, that is worth noticing early.
The constraint made the project. A museum cataloguer has a deliberately narrow, formal register — precisely the kind of voice that composes well deterministically. Had the concept needed free-form emotional prose, losing the model would have hurt. It needed restrained institutional language with fixed slots, and Python does that convincingly.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article