Tidy Datacenter

There is a genre for this now

Over the last few years a genre quietly appeared that most people still cannot name: tidy games. No timer, no enemies, no fail state. You unpack boxes into a new flat (Unpacking). You clean a mud-caked patio inch by inch (PowerWash Simulator). You line up a drawer of pencils until it is finally right (A Little to the Left). The entire reward loop is turning mess into order, slowly, on purpose.

They are enormously popular. And almost nobody in infrastructure has noticed — which is odd, because tidiness is half of what we do.

Tidy Datacenter is that genre pointed at a Clos fabric.

The game

Two spine switches, four leaf switches, 64 ports, one grid. You draw every cable by hand, tile by tile. Cables cannot share a tile unless you spend one of a limited supply of bridges, so the neat route and the cheap route are almost never the same route. Drawing is deliberately slow and slightly tactile — a pencil line with a hand’s unsteadiness in it, synthesised foley that tracks how fast you are moving.

Then the fabric goes through 154 failure scenarios. Cut cables. Dead ports. A failed ASIC. A pulled line card. A whole spine. A spine and a line card on what is left. The board plays them back in front of you — passes flick by, failures hold — and you get a score on a five-rung ladder.

The educational part is the mechanic, not the text

Here is the thing I most wanted to get right.

You can wire all 32 cables, have a perfectly working fabric, and score two stars out of five. Not because you made a mistake the game can point at — every link is up, every leaf reaches every spine, traffic flows. You score two stars because you put four cables on one line card.

Nothing explains that to you in advance. You find out because the test pulls that card and the leaf goes dark.

That is the whole design thesis. The lesson is fault domains nest — a port sits in an ASIC, an ASIC sits on a line card, a line card sits in a switch, and each fails as a unit, so four cables mean nothing if all four die together. You can read that sentence in five seconds and it will not stick. Watching a switch you personally wired lose every uplink because you bunched its cables is a different kind of knowing.

The ladder is strict — no rung without the one below it — so the difficulty curve is the concept hierarchy:

Rung	What it asks
Wired	every leaf reaches every spine, no port dangling
Link-safe	no single cable or port failure costs a path
ASIC-safe	every bundle spread across the ASICs at both ends
Card-safe	same, at line-card granularity
Fabric-safe	lose a spine and a card, every leaf keeps two uplinks

Getting stuck is informative. Stalling on ASIC-safe while Link-safe is lit tells you precisely which abstraction you have not internalised yet.

The addictive part

Redundancy is the lesson. Frugality is the sport.

Every board is ranked on three separate leaderboards, because the three things pull against each other and a single ranking would have to pick a winner and hide the choice inside a sort order:

• Fewest bridges — crossings spent. Par is 116.
• Fewest tiles — total cable laid.
• Tidiest — a computed score for straight runs combed into shared lanes, with no wandering. Weighted toward combing, because that is what cable management actually is, and what a person sees first.

Par is published and explicitly not a ceiling. The reference solve is a machine’s answer, baked offline; beating it is the point, and a player who combs their runs beats the machine on tidiness immediately.

The replay loop is the one every good puzzle game has: you get better at a board each time you run it, and the number you are chasing is your own.

Why I built it

We have a practitioner problem in technology. Not a knowledge problem — the documentation is excellent and the courses are everywhere. What is scarce is the hands-on judgement that only comes from having done a thing, gotten it wrong, and felt the consequence. You cannot get that from a slide about fault domains. Historically you got it from a lab, a maintenance window, or an outage.

Games are unusually good at exactly this. They are consequence engines. They let you be wrong cheaply, repeatedly, and in a way that is memorable rather than expensive, and they make the repetition something you want to do. That is the same loop as a lab, minus the hardware budget and the 2am page.

Tidy Datacenter is a deliberately small test of that idea: take one concept that is genuinely hard to internalise from reading, make the mechanic be the concept, and see whether people come out the other side understanding fault domains. If that works at this scale, it works for BGP path selection, for failure-domain sizing, for capacity planning, for most of what we currently teach by anecdote.

How it is built

Deliberately austere. Zero runtime dependencies — plain ES modules and canvas 2D, no framework, no build step. It runs on Cloudflare Workers with D1, serving the game and the API from one origin.

The property that makes the leaderboard trustworthy: the server re-scores every submission with the same code the browser ran. If a client sends a star count, it is ignored rather than validated. Verification costs about a millisecond because the server never routes — finding a path is the player’s job, and replaying one is cheap.

A few decisions I would defend:

• The pure core. Scoring, routing, levels and verification have no DOM, no clock, no randomness — which is what lets the Worker import them directly and lets 152 tests check the ladder against thousands of deliberately-flawed wirings.
• Levels declare which rungs they can test. A rung that every wiring passes is a free star; one that nothing passes is a locked door. Which rungs ship is derived by sampling, never hand-declared.
• Synthesised audio. The pencil is band-passed noise whose brightness tracks drawing speed. A sample cannot do that, and the difference is most of what the board feels like.

What the data said

The first version shipped with one level: 32 cables, 20–45 minutes, and no way to submit until all 64 ports were patched. About thirty people pressed Play. One finished.

Two of the account names told the story better than any funnel chart — Poooedmypants and idontgetit, nine minutes apart.

So the first level is now eight cables and takes a couple of minutes, with a walkthrough that puts coachmarks on the board rather than help text in a panel. The concept ladder is the same; only the size of the first bite changed. That iteration is the part I would want a reader to take from this more than any of the engineering: the game was not too hard, the on-ramp was missing, and the only way to know which was to ship it and count.

Play it → Free, no login, no ads. Takes two minutes to find out whether you actually understand fault domains.