Courtside

A Fire TV app that explains each moment of a real soccer match to everyone in the room at their own level, remembers what each person learned, and answers questions from a phone or Alexa.

Comment

Inspiration

Watching soccer together is great until half the room doesn't know what offside means. The expert wants to talk about the press, the newcomer wants to know why the goal didn't count. A TV is shared, but understanding isn't: each person needs a different explanation of the same moment, at the same time, on the same screen.

What it does

Try it, nothing to install: open the TV app on a laptop (arrow keys and Enter act as the remote), scan the QR code with your phone, pick a level and ask "why was that offside?".

Courtside replays a real match (the 2022 final, Argentina vs France) from open play-by-play data on a 2D pitch: every dot is where a player actually stood. For each of 37 curated moments there is a card with up to three layers: basic for beginners, intermediate for fans, tactical for experts. Up to three viewers watch at once, and the card shows one row per layer the room needs, each labelled with who it is for.

  • It remembers. A concept counts as understood when a viewer presses "Got it", or after its basic explanation was shown to them twice without them asking about it. Understood concepts are not explained again. Once a beginner has understood five concepts, the TV announces "Leo moved up to Fan"; the viewer can undo it.
  • Three ways to ask. The D-pad's "Why?" answers at the easiest level in the room. A phone, paired by a six-character code or QR, asks by voice (transcribed by Amazon Transcribe in our AWS account) or by typing. The Alexa custom skill "court side" takes "this is Maya, why was Messi's goal not offside?". Every answer appears on the TV within seconds, labelled with who asked and how, and written at their level.
  • No accounts. Viewers are first names chosen by the household; the code is the only secret.

How we built it

  • One React Native codebase in the layout of Amazon's multi-TV sample: shared screens, a Vega OS app, an Expo app for Fire OS, and a web export. We ran it in the Vega Virtual Device (SDK 0.24.12112) on a Mac mini; the web build is the hosted demo.
  • A pure domain core (TypeScript, no I/O) shared by the TV app, the phone page and the backend.
  • Domain rules as tests. Nine rules, R-01 to R-09 (who sees which layer, when a concept counts as understood, what a card may say), live in YAML with concrete examples approved by the product owner. One test file runs every approved example against the real code; change a rule and the tests change with it.
  • An honesty pipeline. StatsBomb events become moments with computed facts: minute and phase, score before and after, the effect on the score, a named pitch zone, the concept to teach, the 360 freeze frame where it matters. Models never see raw coordinates. Jargon is defined from a fixed catalogue based on the IFAB Laws of the Game. Claude Sonnet 4.6 writes the cards offline; deterministic checks enforce word limits, defined jargon, no coordinates and no tournament marks; Amazon Nova Pro then judges each layer and rejects any number or claim not in the computed facts. A failing card is regenerated with the problems listed, up to three times.
  • Live answers: Claude Haiku 4.5 on Amazon Bedrock, given the same computed facts and definitions, with Nova 2 Lite as fallback. We chose each model by measurement: Nova Pro agreed with Haiku on 60 of 60 judge verdicts, including 20 deliberately corrupted lines, while for live answers a blind comparison favoured Haiku.
  • Serverless backend with AWS CDK: Lambda behind API Gateway (HTTP API, plus a WebSocket API that pushes answers to the TV), DynamoDB with TTL, CloudFront and S3, and a Lambda function URL for Alexa that verifies request signatures.
  • Cost caps and privacy: 300 characters per question, 30 questions per hour per household, service-wide hourly and daily caps, throttled APIs, an AWS Budget. Audio is not stored, answers expire after an hour, and access logs are off so caller addresses are not kept.
  • 243 automated tests in the root project, plus the TV app's own.

Challenges we ran into

  • No Windows path for Vega. We wrote the Vega app blind (type packages, Metro bundles) and first ran it when a Mac mini arrived.
  • The first Vega build broke in ways the web never showed: the Vega CLI silently replaced our Metro resolver, a focus library shipped React 19 elements to Vega's React 18, Vega's "7.0" React Navigation ports are v6 underneath (the TV crashed after every phone question), and its SVG port left old player names on the pitch. Each is fixed and logged.
  • Models invent soccer facts. Early drafts said Messi's 107th-minute goal "ties the match". Computing the facts first, then judging against them, fixed that class of error.
  • Alexa's simulator sends no voice identity, so we added a spoken name ("this is Leo").

Accomplishments that we're proud of

  • Three viewers, three explanations, one screen, without anyone being talked down to or lost.
  • The model never decides a fact: code computes them, a second model checks them.
  • Product rules that are executable tests, not a document nobody reads.

What we learned

  • Language models are good writers and poor witnesses: give them facts, then check the output against those facts.
  • Choose models per job by measuring: the best writer, the fastest answerer and the strictest judge were three different models.
  • Test on the real device early; most of our Vega bugs were invisible on the web.

What's next

  • Run the judge on live answers too: today they are checked only by a word limit.
  • Reconnect the TV's live link on its own after a long idle.
  • Voice ID on a real Echo device, more matches, and a licensed data feed for a commercial Appstore release.

Built With

Share this project:

Updates

Submission history