Howdy, I'm
Jackson Schacher

The scene needed to read as one physical place lit by one sun, not a fish model floating over a generic ocean shader. Every surface — the water's fresnel shading, the riverbed, the light shafts, the drifting silt, even the lit flank of the fish themselves — samples the same real-time caustics texture, so moving the sun slides one light net across all of it instead of several effects drifting out of sync.

The flocking engine is dimension-agnostic 2D boids over a spatial grid, reinterpreted as world X/Z only at the render boundary. Five of the eight DART-tracked species drive the flock; each authored fish model is a single skinned mesh with a baked Vertex Animation Texture, drawn as one InstancedMesh per species with tailbeat rate derived from real per-fish swim speed rather than a fixed frequency. Everything that plots against the timeline — the HUD's chart, the data-plates drawer, the fish viewer's sparkline — shares one date-to-x mapping, so the scrubber cursor never reads against two curves differently.

Ten counting seasons (2006–2015) of real Lower Granite adult passage counts are vendored and swappable from a season select, rebuilding the chart, HUD, and plates in place. A slide-in drawer surfaces the season against its ten-year mean, species composition, river conditions, and run history, and a separate labeled fish viewer holds its anatomy callouts steady under a swimming, turning fish by pointing each leader line at the animated vertex while laying the label out against the resting one.

A product that's never been sold has no claims history to validate against, so there's nothing to measure basis risk against. Using NOAA's Storm Events Database as a loss proxy solves that, but a proxy can be wrong, so every backtest also fits a held-out logistic regression to flag when the local data is too thin to trust the basis-risk number at all.

An organization defines a trigger candidate, a peril, station, threshold, operator, and window, which queues a backtest job on Redis for a worker to pick up. The engine slices two decades of NOAA GHCN-Daily observations into consecutive, non-overlapping windows the length of the policy term, computes the peril's aggregate for each one, and checks it against NOAA's Storm Events Database as an independent proxy for real documented loss. A logistic regression fit on the same windows reports a held-out AUC alongside the result, so a low-signal station reads as "the proxy can't judge this threshold" rather than as a false failure.

Each run returns a false trigger rate and a missed loss rate, one per side of the contract, averaged into a single basis-risk score, plus a threshold sweep suggesting where to write the trigger for a target return period. Both NOAA datasets are cached in Postgres so re-ingestion only tops up new records, and while the demo console's tenants are fake, every backtest on screen runs on the same real weather and loss data a user's own candidate would.

Websockets need a long-lived process, which doesn't fit a serverless app host, but shipping the whole Next.js app onto EC2 just to serve /ws upgrades wastes the build and dependency surface. Splitting the realtime runtime into its own minimal Node process, fronted by Nginx and backed by MongoDB for reconnect hydration, let each half run on the infrastructure it's actually suited for.

The websocket layer used to live inside the main Next.js runtime, so an EC2 host serving only socket connections still had to carry the full app's build and dependency surface. It's since been split into two runtimes: Amplify hosts the Next.js frontend and API routes, while a standalone Node process on EC2 handles only /ws upgrades, sharing a room-lifecycle module that manages reconnect hydration, TTL-based expiration, and vote broadcast to everyone in the room. PowerShell bootstrap scripts drive the EC2 side end to end, pulling the repo, installing just the realtime-runtime dependency set, wiring up the systemd service, and fronting it with an Nginx reverse proxy with optional Let's Encrypt TLS.

The split keeps the EC2 dependency and build surface down to a handful of realtime-only packages, no Next.js build required, while Amplify keeps owning the app deploys it's actually suited for. Rooms persist snapshots to MongoDB so players can reconnect and rehydrate state after a drop, and both session expiration and idle in-memory cleanup run on their own configurable TTLs, so a play session self-destructs 30 minutes after creation without any manual upkeep.

A vague mood like "cozy but a little spooky" isn't something a keyword filter or static tag search can resolve into good picks. Pairing IGDB for accurate, real-time game metadata with an LLM for the actual reasoning splits the problem cleanly: one system supplies ground truth, the other supplies judgment, and the loading screen's elapsed-time progress bar hides the latency of that round trip without ever lying about being done.

On the Find Gems screen you describe a mood in free text, optionally point it at a game you already liked via IGDB autocomplete, and filter by genre, mode, and keyword tags pulled live from IGDB. Submitting POSTs that payload to a Next.js API route, which forwards it through API Gateway to an AWS Lambda that queries an LLM and returns a handful of recommendations with a natural-language reason for each, while IGDB's own OAuth credentials stay server-side and never reach the browser. Each result comes back as a "gem" with its IGDB cover art, summary, and a rarity tier (Common/Rare/Epic/Legendary) derived from its community rating.

The result turns a vague "something like Hollow Knight but shorter" into concrete, explained picks instead of requiring you to already know what to search for, combining a real game database for accurate metadata with an LLM for the actual matching. A lightweight gamification layer, XP, prospector levels, visit streaks, and achievements, persists in the browser via localStorage to encourage repeat use without requiring an account, with an Amplify/Cognito backend scaffolded for a future move off local storage.