
The Full Stack Challenge - Undercurrent: reading the virtual room through anonymity and queues.
A team-morale app built in 24 hours from the word CURRENT. One anonymous ping a day moves a live Canvas river from calm to storm, pushed to every open window over AppSync subscriptions. Pings carry no author and receipts carry no score, so anonymity is enforced by the schema rather than promised by the UI. Amplify Gen 2, DynamoDB, Lambda, Cognito, and Bedrock underneath.
Series: The Full Stack Challenge (1 article)
- 1The Full Stack Challenge - Undercurrent: reading the virtual room through anonymity and queues. This article
There's a thing you can do on a jobsite that you cannot do over Zoom. You walk in, and within about ten seconds you know. Nobody says anything. The radio's off, or someone's cutting in too fast, or the whole crew is laughing at something dumb—and you know what kind of day it's going to be.
I ran commercial painting crews for years before I moved into software. That ten-second read was the most useful management tool I ever had, and remote work took it away from every lead who used to rely on it.
Undercurrent is my attempt to give a little of it back. It's a team-morale app for remote and hybrid teams, built solo in about 24 hours with Claude Code as a pair, for the AWS Builder Center Full Stack Challenge. My word prompt was CURRENT.
Everyone on the team drops one anonymous mood ping a day. Those pings become a living river, and the river's weather is the team's weather. Good week: calm water, low warm light. Rough week: the sky goes dark and the water starts moving. Everyone watches it change at the same moment, because it's pushed live to every open browser.
Here's the honest thesis, and I want to state it plainly before anything else: Undercurrent shortens the distance between when a team starts struggling and when its lead finds out. That's it. It won't fix anything on its own. It starts a conversation; it does not replace one.
What it does.
____________
Tap a mood from 1 to 5. Add a 140-character note if you feel like it. Press ping. That's the entire ask—ten seconds, once a day.
Once five or more people have pinged in the rolling 24-hour window, the river picks a scene: gathering, clear, breezy, overcast, rough, or storm. Under five pings it stays at gathering and shows you nothing, on purpose. The average never leaves the server.
The river is Canvas 2D, drawn live, with no art assets anywhere. Scenes tween over two seconds rather than snapping, because watching the sky slowly darken lands very differently than a number changing. If you have reduced motion turned on, it renders still frames with a crossfade instead—an animated thunderstorm is a genuine problem for some people, not a checkbox.
Then there's the part I did not expect to become my favorite feature. Every person gets an avatar, and they choose its pose: floating, clinging to a raft, fully underwater, struck by lightning, or kicked back in coconut mode with a drink. They also pick a spot on the river—drifting, the headwater, the rapids, up on the big rock, in the shade, the shallows, or the eddy.
The weather is what the system infers about the team. The avatar is what a person chooses to say. Sliding yourself underwater costs almost nothing socially, and it says something that is genuinely hard to type into Slack. Coconut mode matters just as much, honestly—people need a way to participate on a perfectly fine Tuesday, and a river where everyone's drowning stops meaning anything.
Light and dark themes ship as a header toggle. The canvas reads the same CSS custom properties as the rest of the page, so switching themes re-tints the water, the banks, and the sky along with the interface instead of leaving a dark rectangle floating on a pale page.
Leads get two extra tabs. The team shows the roster and how many people were pinged—never who. Report is one button that produces a three- or four-sentence read of the week plus one concrete suggested action, written by Claude Haiku 4.5 on Amazon Bedrock from aggregates only. A score tells a lead something is wrong. A suggested action tells them what to do about it, which is the whole point.
And because most people reading this don't have a team waiting inside my app, a new sign-up lands in simulation mode: six invented teammates have already pinged, you're the seventh, and your stone tips the weather. Nothing in the simulation touches the live team, a header toggle switches between them, and a "preview build" pill always tells you where you are.
Full-stack breakdown:
____________________
The series takes a product from pitch to launch. Squeezed into 24 hours, every one of those stages still left a fingerprint on what shipped.
Pitch. CURRENT could have been a river, a circuit, or the present moment. I picked the one I had standing to make. Then the idea had to survive the question any decent manager would ask: does a mood dashboard actually improve anything? Honestly? No. Measurement on its own changes nothing—only a person acting on it does. So I narrowed the claim to the one thing I can defend, and I built toward that instead of toward a bigger promise. Writing that constraint down on hour one is exactly why the report ends with a suggested action instead of a number.
Prototype. My first version had avatars swimming freely around a live map. That's multiplayer game networking, and it would have quietly eaten the entire sprint. The prototype pass traded it for fixed spots and six discrete poses—which kept every bit of the emotional payload for the cost of a single mutation. I wrote scope tiers before I wrote code and treated everything below tier one as deletable. I did end up deleting some of it, and the app is better for it.
MVP. The minimum was never "an app with a river in it." It was proof that a ping in one browser could visibly change a river in another. I built that path end to end while it was still ugly and left the drawing until after it worked.
UX. The default shape for mood data is a gauge and a line chart, which is the most forgettable artifact in software and, for this subject, faintly insulting. So the interface is a place instead: a riverbank palette of silt, stone, reed, sun, foam, and clay, one severity number driving every visual at once, and the current scene named plainly under the water. You should be able to read your team's week from six feet away.
Launch. Deploying on hour one—before there was anything worth deploying—is the single reason a broken build was a five-minute annoyance instead of a submission-day catastrophe. Simulation mode exists because launching to strangers is a different thing than launching to a team.
Architecture
___________
Amplify Gen 2 provisions all of it from TypeScript: Cognito (email and password, with lead, member, and a dev group for testing), AppSync over DynamoDB, two Lambdas, Bedrock, and Amplify Hosting with CI/CD from GitHub. Five decisions carry the whole design.
Anonymity is structural, not promised. Ping has a score and no author. PingReceipt has an author and a day key and no score. One ping per day is enforced on the receipt: its ID is userId#dayKey, and a conditional write makes DynamoDB itself refuse the second receipt of the day. This is the decision I'd defend hardest. An interface can promise anonymity and quietly be wrong two features later. A schema cannot leak what it never stored—and if people don't trust the anonymity, they lie, and the entire app becomes an expensive way to generate a flat line.
Weather is a materialized view. Clients never compute weather locally. A TypeScript Lambda on the Ping table's stream recomputes one WeatherState row per team, which is also where the five-ping floor lives, somewhere nobody can reach around it. Subscribers receive one tiny row instead of a firehose of pings.
The Lambda mutates through AppSync, never straight to DynamoDB. Subscriptions fire on mutations that go through AppSync, not on table changes. If that Lambda wrote with PutItem, every client would sit there watching a stale river, and nothing would look broken. It's the riskiest wire in the system, which is exactly why I proved it on night one.
Buy the real-time layer. Hand-rolling WebSocket fan-out is weeks of work. AppSync hands it to you as a property of your schema. In a 24-hour build, that's not a shortcut; it's the whole reason the app exists.
One shared severity number drives waves, water speed, clouds, rain, lightning, bank color, and how hard the avatars bob. Six scenes stay cheap to build and, more importantly, coherent—everything moves together because it's all reading the same value.
The report path is the deliberate exception. The button writes a ReportRequest row; that table's stream triggers a Python 3.12 Lambda that assembles counts, daily averages, and deduplicated, shuffled notes, calls Bedrock's Converse API, and writes the finished Report straight to DynamoDB. The lead's browser polls for it. Hand-signing AppSync calls from Python wasn't worth it for a lead-only surface used once a week. Haiku 4.5 was a matter of availability, not cost — the Opus and Sonnet tiers are sales-gated on a brand-new AWS account.
How I built it
Deploy first; panic never. My very first CI build failed anyway: npm ci rejected a lockfile npm had just written, a known bug where it omits bundled dependencies' subtrees. Regenerating the lockfile didn't help. An amplifier. yml switching the build to npm install did, and build #2 went green. On hour one, that's a coffee break. At hour forty-six it's the whole submission.
I proved real-time with a script instead of my eyeballs. scripts/prove-realtime.ts signs in, subscribes to WeatherState, submits a ping, and fails loudly if nothing arrives within 30 seconds. Two browser windows and a hopeful squint is not proof.
Bedrock ambushed me regardless. Every invoke came back AccessDenied—not model access, but new-account verification. A 10-second CLI test caught it before the Lambda even existed, so I built the whole feature while AWS finished verifying me. Then a second gate appeared: Anthropic models need a one-time use case form that the console hides beautifully and the CLI does not (aws bedrock put-use-case-for-model-access). Fifteen minutes after submitting it, the Python Lambda wrote its first real report.
Before submitting, I ran a multi-agent adversarial review — 32 agents, 28 findings, 23 confirmed and fixed the same night. Two stand out. Amplify v6's signIn resolves rather than throws for unconfirmed accounts, which meant anyone who abandoned the confirmation email hit a dead screen. And nothing stopped a crafted score of 9999 from pinning the weather at permanently clear, which is a very funny way to gaslight an entire team. A second pass (18 agents, 9 confirmed) noticed my 30fps throttle was actually running closer to 20.
The river took four drafts to stop looking wrong. A flat horizon read as "ocean," not "place." A stream running toward the viewer was better. A corner-to-corner three-quarter view — built as a sampled path of 80 points — finally gave the reeds, rocks, and named spots a tangent and normal to hang off, which is what made them feel located rather than sprinkled. The final version turned that path back toward the viewer, a change to the path generator instead of a rewrite. Offset curves taught me the same lesson twice: a riverbank folds into a fin when the half-width exceeds the centerline's bend radius, and fading the meander out just relocates the fold upstream into a hook. The fix was a gentle meander confined to the upper 65% of the path, with a squared sine envelope.
An outside design pass used the silt token as dark text. In the light theme, silt is the pale page ground—so every inherited heading turned invisible. Tokens are roles, not colors. Silt is the ground, foam is the text, and I now say that out loud before handing anyone a palette.
The first real tester was me, with a real email, on the public URL, on my phone. Three bugs, three completely different root causes. Poses landing on the wrong character turned out to be a shared browser session—Amplify keeps one signed-in user per browser, so signing in on a second tab silently swapped the first tab's tokens. The laggy page was device pixel ratio: at DPR 3, my river was a roughly 3500 px-wide backing store being redrawn 60 times a second. It's capped at 1.5 now, throttled to 30 fps, and paused when the tab is hidden. And "no dev access" was, embarrassingly, just group membership.
What I learned
Deploy on hour one. The lockfile bug cost me minutes on night one instead of the entire submission.
Prove the riskiest wire with a script that can fail, then run it against production. Optimism is not a test suite.
Enforce your invariants in the data model, not the interface. Interfaces drift. Schemas don't.
Check an external service with a 10-second CLI call before you build on top of it.
Test the way strangers will. Headless private windows never once saw the shared-session bug. One real sign-up on my own phone found it in four minutes.
What's next?
The receipt-and-ping pair is currently orchestrated by the client, which means a hand-crafted API call could create a ping without a receipt, and a hostile account could pre-create someone else's receipt ID. Real enforcement is a custom mutation doing both writes server-side, and it's first on the list. After that: multi-team support, the EventBridge weekly scheduled report, and weather that decays back toward calm as pings age.
I keep coming back to something about the coconut. It's the silliest thing in the app; it took twenty minutes to build, and I think it might matter as much as the anonymity model—because a tool people only open on their worst days becomes a tool nobody opens.
Undercurrent doesn't tell a lead what's wrong. It just shortens the time until they ask.
Series: The Full Stack Challenge (1 article)
- 1The Full Stack Challenge - Undercurrent: reading the virtual room through anonymity and queues. 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