AWS Builder Center

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

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 of
the 37 attempts that did not succeed, only of the one that did.

ORIGIN Recovered from a solo encounter with Malenia.
PERIOD The small hours
CONDITION 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 allowed
us.anthropic.claude-haiku-4-5-... -> ValidationException: Operation not allowed
us.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:
  1. 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 so  After  and  My  aren't mistaken for proper nouns.
  1. 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.
  1. Seeded selection —  random.Random  seeded from  hashlib.sha256(memory) . Never Python's built-in  hash() , which is salted per process and would hand you a different card on every Lambda invocation.
  1. 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.html  as the error document so client-side routes survive a refresh
  • Amazon API Gateway — HTTP API, payload v2, fronting Lambda
  • AWS Lambda — Python 3.12,  boto3  only, no external dependencies
  • Amazon DynamoDB —  reliquary-cards , on-demand; partition key  id , GSI  owner-index  on  ownerId  +  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.
Links:  Live app  ·  GitHub 
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