Alex Bristow

Draftastic

Live team picking and tournaments for clubs, schools and events. The room watches on a big screen while everyone follows their own part on their phone, with nothing to install.

Year
2023–26
Type
Personal project
Website
draftastic.co ↗
The Stage on the projector, and each person's Ticket on their phone. The organiser has a third screen of their own.

An hour in a spreadsheet

I built Draftastic in 2023 after watching a tournament spend over an hour sorting 100 people into 20 teams, with captains calling out picks and one person typing them into a spreadsheet. In Draftastic, captains pick and everyone watches the teams fill in on a big screen and on their phones.

The first version did that job and people used it, but I'd built it for the organiser. Setting up a draft took four steps and a long list of options, and everyone else had to sign in before they could join. In 2026 I rebuilt it around the people taking part, with two requirements. Anyone in the room should be able to use it without help, and when it's on a projector in front of a hundred people, it can't fail.

From picking teams to a season

There are five ways to make teams:

  • Captains take turns to pick, with a coin flip for first pick, a timer and a choice of pick orders.
  • The organiser picks every team by hand.
  • People choose a team for themselves.
  • People say who they'd like to be with, and the teams are made around it.
  • Draftastic deals the teams instantly, at random or balanced on people's answers to a few questions, or with AI.

With AI, the organiser writes what they want in plain English, like one goalkeeper on each team and Maya and Omar kept apart. A model returns the teams with a checklist of what it took the request to mean. The draft engine checks every item on that list against the teams, moves anyone it has to, and writes the summary the organiser sees, so it never says a rule held when it didn't.

Once the teams exist, the same event runs what they play: a league, groups then a knockout, a straight knockout or a scoreboard. Players can report their own scores, and the tables and brackets update themselves on the Stage and every phone. A club can run a league over a season, with divisions, promotion and relegation, and cups alongside it. Schools, clubs and competitions each start from a preset. In a school draft, people join by code, see first names only and have no chat.

Designed for the room

A draft has an organiser, a big screen and a lot of phones held by people aged nine to ninety who didn't plan to install anything. So each role gets its own screen. The organiser runs the event from Setup, and the Stage goes on the projector or stream. Everyone else gets a Ticket: their own screen on their phone, showing when it's their turn, which team they're on and, later, their scores. Nobody sees a control they can't use.

Joining takes a link, or a six-character code, and a name. There's no account unless the organiser asks for one. Each guest still gets their own session. They can only act as themselves, and they can turn it into an account later. Codes skip characters that are easy to misread aloud, and the bar I set was two taps and one field from the link to your own screen.

The rebrand came from the same aim. Every word is set in Lexend, a typeface designed to be easy to read. The interface is ink, and colour is kept for teams. Each team is a colour, a shape and a name, so nobody needs to tell orange from red to find theirs. Text is at 7:1 contrast and targets are 48px, and tests check both. The Stage scales its type from 720p to 4K and turns to a second page rather than shrinking names to fit.

One server for each draft

The server decides everything. The draft's rules live in a separate package with no database or network code, so any draft can be replayed exactly, and property tests try each rule against hundreds of generated drafts. Each screen is sent only what it's allowed to see, so a hidden reveal never reaches a phone before the Stage shows it.

The rebuild first went live on a stack much like the first version's: the app on Vercel, Postgres on Supabase, a WebSocket server I hosted myself on Railway, and Upstash for rate limits and queues. It worked, but that was four services that all had to agree for one pick to reach a phone, and I was looking after one of them myself. So I moved everything to Cloudflare. Durable Objects decided it: each draft gets one small server of its own, with its own database, which holds the draft's state and the connection to every phone in the room. That replaced the WebSocket server. Because one object handles every pick for its draft, one at a time, it also replaced the locking and repair code that had kept picks in order. A pick is saved and sent out in the same step, so no phone hears about a pick that wasn't saved.

StackCloudflare Workers, Durable Objects, D1, R2, Queues, TanStack Start, React, TypeScript, Drizzle, Better Auth, fast-check, Playwright

What goes wrong in a room

Rooms are hard on software, so the rebuild was planned around what goes wrong in them. School and venue Wi-Fi often blocks WebSockets, so a phone that can't open one falls back to ordinary requests and carries on. A tap sent twice on a bad signal only counts once. A phone that wakes from sleep catches up on what it missed, and waits a few seconds before showing a connection warning, to avoid flashing one every time. When a whole room of phones reconnects at once, they're spread out rather than all hitting the server together. Two events on one school's network don't block each other's joins. And if the TV drops out, the organiser has one place to reconnect it or move the Stage to another screen.

Proving it before the room

A draft holds up to 1,000 people, so I tested at that size, with simulated phones on staging and a target for each measure set in advance. A pick reached all 1,000 phones within 252ms at p95, against a target of 300ms. When I crashed the draft's server on purpose, every phone was up to date again within 5.4 seconds, with nothing lost. When 500 people joined at once, they got in within 735ms at p95, against a target of 1 second. The first run took 2 seconds, until joins that arrive together were saved together. CI runs over 10,000 tests, including accessibility checks in the browser tests.

I ran the rebuild like a small team, with coding agents as the engineers. I made the architecture calls and split the work into parts that could be built in parallel. Nothing merged until the full test suite and browser runs passed. When an agent said something was done, I sent it back to prove it.