In a company with no managers, the tool is the org design.

The stakes: transparency did the managers’ job — until two hundred people broke it.

The whole thing runs on transparency: salaries, finances, project assignments, reviews — open to everyone. That holds at forty. At two hundred, the hallway stops scaling. What lives in one person’s head stays there, and the org grows a quiet hierarchy to route around the gap.

The ask said design tooling for a 200-person company with no management layer. The actual ask was narrower and harder: coordination with nobody standing above anybody. Every obvious feature — task assignment, approval flows, escalation paths — quietly appoints somebody the router.

Here the user base and the org structure were the same two hundred humans. So every design decision was an organisational one — there was no other kind. Get a screen wrong and you don’t ship a bug; you reintroduce the boss the whole company was built to do without.

The test: every safe feature had a manager hiding inside it — the design work was refusing them.

Every coordination tool ships the same defaults: assign the task, route it for approval, escalate when it stalls. Each one quietly puts somebody above somebody else. Build them and the org chart grows back overnight — just rendered in software instead of titles. The thing that made the company itself would have died in the tooling meant to support it.

So the real deliverable was never a feature list. It was a coordination model that could carry 200 people across 8 modules without ever electing a router — and the discipline to refuse every feature that smuggled one back in.

The mechanism

I made transparency do the coordinating — pull, not push.

The one decision: replace assignment with visibility. Who’s on what, who’s blocked, who decides — visible to everyone, always. Pull, not push. Commitments, not assignments. Nobody hands you work; you see what’s open and you pick it up. Eight modules — staffing, comp, OKRs, onboarding — all spoke one object model, so the org could rebuild its own process with nobody in the room to arbitrate.

The board above is what it looked like; the one below is the same surface, live — flip transparency off and watch the coordination go with it. An open ask sits there until someone chooses it. That switch is the whole argument in one control.

When it was done: not when the screens shipped — when people committed unasked.

A board nobody trusts is just a prettier inbox. The design wasn’t done when the screens shipped. It was done when people trusted them enough to commit — unasked. Coordination is a trust problem between people — the same problem I design for everywhere else, here just without a model in the loop.

Falsifiable evidence — zero managers since launch, 250 people today.

The test of a coordination model isn’t the day it ships — it’s the day the org outgrows the number it was designed for. The company has since grown to 250 people across a far more diverse set of teams, and they still run on it. The hallway that stopped scaling at two hundred didn’t come back. Scoping the credit: zero managers is the founders’ philosophy succeeding, and these numbers belong to the org. What I own is narrower and harder to fake — the tooling held when the philosophy met scale.

Where the principle breaks.

This only holds where the org has genuinely committed to self-management — the tool can’t create that commitment, only carry it. Two hundred people was near the ceiling: pull-based coordination leans on everyone reading the same surfaces, and that thins as headcount grows. And in a company that HAS managers, forcing manager-shaped work through managerless tooling doesn’t remove hierarchy — it hides it, which is worse. The principle is for orgs that mean it.