Inspiration
It's 4:55 on a Friday. Your board looks exactly like it did on Monday. Nothing in To Do has moved, "Quick question (87 comments)" is still open, and someone has just added a ticket called "asdf".
Software teams spend their working day inside Jira. It's where the meetings point, where the status lives, and where nothing is ever quite finished. We wanted one thing in Jira that is the opposite of all that: something you can't be bad at, that ends in two minutes, that nobody measures, and that gets the whole team laughing at the same moment.
So we turned the board into a race track.
What it does
Desk Derby turns any Jira project you can see into a paper race track across a desk. Its columns become stretches of track, left to right, and the finish line is Done.
- Your tickets are the racers. Each one becomes a little folded-paper creature built from the ticket itself:
- Bodies by issue type: bugs are pleated pink caterpillars, epics are manila folders, tasks are index cards and stories are sticky notes.
- Personality from the title: a ticket's own words give it traits. "Fix" and "typo" run quick, "migrate" and "refactor" run heavy, a question gets chatty, and "ASAP" sprints off the line and then burns out.
- You back one with coffee beans. They are not real beans. Bet that it wins, or take the Wooden Spoon and bet that it comes last.
- You rig the track with desk items: a Stapler Ramp, a Desk Fan, a Coffee Spill, a Fridge Magnet, a Rubber Band, and a Rubber Duck that "will not move, will judge". Items act differently on different traits, so where you put them changes who wins.
- Then you watch, for about ten seconds. Each race is decided by real physics in an instant, then shown like a sports highlight: fast-forward through the quiet stretches, real speed for every ramp, spill and overtake, slow motion into a close finish, and a Polaroid photo finish. An announcer calls your actual ticket titles. These lines are from a race on a real board:
- "Contact between 'IT Help Problem' and 'Read handwriting on signature screen'! A meeting will be scheduled."
- "'redeploy #23 asap' marked itself URGENT and is leading accordingly!"
- A season runs four quarters, each with a bean target, a Supply Closet between races, and a boss race at the end:
- CODE FREEZE: the track is iced.
- THE AUDIT: your items are switched off.
- MANDATORY FUN: everyone is bouncy.
- YEAR-END REVIEW: the track is twice as long, and so is the meeting.
Miss your target and you're reassigned.
- It never touches your work. Desk Derby only reads, and only as you. When the race ends, the board is exactly as it was. Nothing in Jira was harmed.
Who it's for
Software teams, and remote ones most of all, who have Jira open all day and no shared break room. Desk Derby gives them a two-minute moment together inside the tool they already use, with nothing to install per user, nothing to configure and nothing to administer. We make no productivity claims, and the game has no work metrics anywhere: it uses the shape of your board, never a judgement of it, and nobody is ever the target.
How we built it
- Forge, with a Custom UI.
- Module: a
jira:globalPagewith a blank layout. - Resolver: one resolver reads Jira as the viewing user (
api.asUser().requestJira), using only GET requests for projects, statuses and issues. - Scope:
read:jira-workis the only permission. - Runs on Atlassian: there is no egress, no external service and no AI or LLM of any kind. Forge reports the app as eligible.
- Module: a
- From board to race. A pure, tested mapping:
- Statuses become between three and six stretches of track, in board order.
- Tickets become racers with traits taken from their type, the words in their title and their comment count.
- Physics.
- planck.js (a Box2D port) runs on a fixed 1/60 s step.
- Every random choice is seeded, so a race is fully determined by its seed and the items on the track. The same race drawn twice gives identical frames.
- The odds come from simulating each race 12 times before the start, not from a table. The bookie keeps about 11%.
- Simulate instantly, then broadcast. When you press Start, the whole race (about 20 seconds of physics) is simulated in a few milliseconds and recorded. A director then plays it back:
- An event-aware time map: fast-forward between moments, real time around item hits, lead changes and bumps, and slow motion into a close finish. About 9.5 seconds of viewing per race.
- A camera that knows the future: because the whole race is known, it frames the leading pack and is smoothed over the frames on both sides, so it never lags or hunts.
- The core of the shared race: simulate once, record, and everyone watches the same race.
- Everything is drawn and voiced in code.
- A canvas renderer draws procedural paper grain, felt-tip outlines, tape and rubber stamps.
- Every sound is generated with WebAudio.
- Two fonts are bundled.
- Nothing is fetched from outside, which keeps the app clean under Forge's strict content security policy.
- Tools. TypeScript and Vite throughout. Built with Claude Code as an AI pair-programming assistant.
Challenges we ran into
- Our first idea was a slingshot game, and it turned out to be Angry Birds with tickets. We kept one test from that: if you swap your real board for random data, the game must get worse. In Desk Derby your own tickets, with your own titles, are what you cheer for.
- Our first races were 40 seconds of watching, and when we played them ourselves, interest drifted. A livelier live camera didn't fix it. What worked was the video trick: decide the race first, then broadcast it with a time map and a camera that already knows what happens. A race is now about ten seconds, and the drama lands at full size.
- Forge Realtime delivers messages in about a second in our measurements, which rules out twitch multiplayer. So a race is decided entirely by its seed and the items on the track. That keeps it fair, and it means a shared team race can run asynchronously.
- Judges and new teams have nearly empty sites, where every ticket is a week old and called "Test issue 1". The practice board needs no data at all, and real boards full of junk still make a fun field, because "asdf" beating "Test issue 2" is funny.
- The content security policy blocks inline styles, eval and external assets, so every pixel and every sound is made in code.
- Making a ticket title read as a creature at 60 px tall.
Accomplishments that we're proud of
- It's a real game, not a dashboard in a costume.
- A race replays identically from its seed, down to the pixel.
- It's read-only by design, with a single scope, and runs entirely on Atlassian.
What we learned
- A game built from your own content is only interesting if the content changes the play, not just the paint.
- A full canvas game with physics and sound runs inside a Forge Custom UI frame, provided every asset is bundled and every pixel is drawn in code.
- The empty site is the real first impression, so we design for it first.
What's next
- The Friday Derby: through the week, each teammate places one item on a shared track. At 4 pm the race runs once, and everyone watches the same race. The simulate-once broadcast it needs is already built.
- An MCP tipster, so an agent like Claude Code can read the race card and place a tip from a terminal.
- A Rovo ringside announcer.
- A Confluence page as a track, and a "race this ticket" button on the issue view.
Built With
- atlassian-forge
- canvas
- custom-ui
- jira
- jira-rest-api
- planck-js
- typescript
- vite
- web-audio