CASE 09 · LIVE EVENT PLATFORM

From a six-person group
to an 80-person event.

Problem
Every event had a different crowd, age group and venue, and the host, stage and participants each needed their own screen and controls.
Decision
Kept host control and fallback paths as fixed principles, and re-chose screens and connections for each event.
Verified outcome
Built five event apps; the last was designed for about 80 people in nine teams and used at the live event.
Stage display with a bomb moving between nine team tables · actual app UI · sample data
Stage display · rendered from the actual app UI with sample data
My role
Event planning · game and scoring rules · per-screen experience · spec writing · AI-assisted development and review
Built with
JavaScript · Python · long polling, SSE, WebRTC · three.js · cloud and local modes
Event apps
5children’s teams · small group · booth role-play · full young-adult event
Largest event
~80 people · 9 teamsas planned · 4 screen types · 15 games
Pre-event checks
6 toolsunit · simulation · smoke · load · reconnection
01 / FIVE EVENTS

Each event,
a different structure.

I didn’t repeat the same games. Inputs and screens changed with participants’ ages, headcount, the venue’s network and whether one host ran everything — and the parts that worked moved on to the next event.

  1. 01

    Children’s team games

    Eight motion games using each team’s phone camera as input. Pose recognition runs offline on a Mac.

    camera · pose recognition · team scores
  2. 02

    Six-person small group

    The first split into host console, stage display and phones: seven mobile games plus host-led rounds.

    three screens · device checks · score undo
  3. 03

    Booth role-play

    Twelve one-on-one “review” games parodying a public service counter, with difficulty designed around target pass rates via a roulette and appeal rules.

    operator console · customer monitor · two keyboards
  4. 04

    Children’s games, part 2

    Replaced the camera input that triggered security warnings with team buzzers, correcting clock drift between devices to judge who pressed first.

    SSE · clock correction · number-key fallback
  5. 05

    Full young-adult event

    About 80 people in nine teams. Table tablets became a fourth screen, and the app runs both in the cloud and locally.

    15 games · alliance rounds · awards
02 / SCALE

A six-person design
couldn’t hold 80 people.

When the small-group server was tested at 80-person scale, most connections failed. Before adding screens or games, I redesigned how state moves between them.

Team table tablet showing an arriving bomb and team mission progress · actual app UI · sample data
Table tablet (team screen) · teammates’ phone inputs add up here
Stage display introducing a game and its rule · actual app UI · sample data
Stage display · one-line rules, answer choices on each phone
01

Only the state each person needs

Each phone receives only its own state; broadcast data is cut to the top ten plus aggregates. After a refresh, screen lock or a Wi-Fi/LTE switch, people return to the same team, name and record.

02

A fourth screen at every table

A tablet on each table became the team’s own screen, gathering connection status and team missions — and serving as the stage for team games like Hot Bomb.

03

Cloud and local, one codebase

The event runs at a public address with a host key; rehearsals run on my Mac. Console state is backed up on the server, and redeploying mid-event is ruled out.

04

Heavy visuals only on big screens

3D staging runs only on the stage and tablets, with automatic CSS fallback if it fails to load. The 80 varied phones draw lightweight screens only.

03 / FAIR SCORING

Before fun,
scores people accept.

Teams differed in size and included first-time visitors. Rules were fixed in the spec first, so points reflected how teams played — not how many showed up.

01

Correcting for team size

Team totals are the members’ average multiplied by the largest team’s headcount, with non-participants counted as zero, so smaller teams compete on equal terms.

02

Alliances ranked as alliances

When three teams form an alliance, ranks are assigned per alliance and points spread to its teams — avoiding the error where three tied winners push the next team to fourth.

03

The host reveals the scores

Team scores stay hidden until the host chooses to reveal them. Results wait after each round until the host moves on, so the room sets the pace.

04

First-timers included

First-time visitors get a small badge, and insider-only topics were removed from questions. A friend-introduction quiz and chat opened the event.

Actual host console from the small-group version · isolated copy · names anonymized
Actual host console from the small-group version · isolated copy · names anonymized
04 / OPERATIONAL DESIGN

Designed for what goes wrong,
not only for what goes right.

The principles that survived all five events. Device differences, mis-taps, dropped connections and host mistakes have to be recoverable mid-event.

01

The host stays in control

Every round advances only when the host moves on. Results are reviewed before scoring, and a whole applied batch can be undone at once.

02

A fallback for every input

No phone? Number keys. No camera? Team buttons. No motion sensor? Taps. No 3D? 2D.

03

Device checks inside the product

Connection, browser, buzzer, camera, shake, vibration, sound and screen wake are checked before the event, separating unsupported features from real errors.

04

Knowing what to remove

Part 2 dropped the camera to avoid security warnings; part 1 switched from finger to palm detection after watching the room. Flow comes before features.

05 / AI COLLABORATION

Code shared with AI,
decisions kept in the spec.

Implementation was done with AI coding agents. My job was to pin down in writing what to build, what was still undecided and how it would be checked.

01

Decision boundaries in writing

Scoring, run of show and each screen’s role were fixed in a final spec whose first line reads: don’t make decisions that aren’t here — report them as “decision needed”.

02

Parallel work through module specs

Games were split into modules with one interface so several agents could build at once. Agents role-played participants to surface rule loopholes early.

03

Pre-event checks and rehearsal

I had tools built for simulating all 15 games, load, reconnection and smoke tests, then ran a rehearsal — fixing instant results, name legibility and a missing team score before the event.

The standard that carried over

What mattered more than the number of games was a show that never stalls. Screens, inputs and scale changed at every event; host control and fallback paths carried on to the next app.

Evidence and scope

Based on local source, user guides, the final spec, test tools and development records for all five apps. 80 people and nine teams are the planned and rehearsed scale; actual attendance and final scores were not recorded and are not claimed. Load-test tooling and runs were confirmed, but no saved result file exists, so no figures are cited. Stage and tablet images render sample data with the actual app’s UI code; the host console is an isolated copy of the small-group version. The booth game’s face feature only detects whether a face is visible and does not identify anyone. Participant photos, names and event data are not published.