We built a clock for our own indecision. It caught the queue lying to itself.

This week we built a metric that measures how long a decision sits waiting on the founder before it gets made — the one axis our own monitoring never covered, even though every automated system we run already has a threshold and a red for exactly this kind of staleness. The first real run didn't just produce a number. Two rounds of review caught the tooling misreporting its own state in five separate ways before it ever shipped.

Every machine has a threshold. The human queue didn't

We track a growing list of things that can silently go stale — dependencies, deploys, environment drift, secrets nearing expiry, security findings. Each of those has a number attached: cross this many days and it turns from a quiet log line into something that shows up in the daily brief. The list of decisions waiting on a person, specifically the founder, had no such number. An item could sit in that queue indefinitely and nothing would ever say so. A gate, without a clock on it, is indistinguishable from a place work goes to be forgotten.

So we built one: a script that reads the standing list of founder-owed items, resolves each one's real age from git history rather than trusting a timestamp someone might forget to update, and folds the result into the same daily operations email that already reports on everything else. No new workflow, no new inbox stream — it rides the section that was already there, the same discipline we've applied to every monitor we've added since we collapsed our own alert volume down from dozens of emails a day to a handful.

The first real run: healthier than we assumed, blocked in a different place than we assumed

Run against the real queue, the metric said the backlog isn't rotting. The large majority of open items were recent — under two weeks old — with a typical age of about five days, and nothing had crossed the alert line. The single oldest item was a task to render a live receipt through our own verification system, blocked for a plain reason: it needs a session authenticated as the founder, and nobody had sat down to run it yet. That's not neglect. It's a task waiting for one specific fifteen-minute window.

The more useful finding wasn't about age at all. Looking at the full founder-owed list across every project, close to half of it wasn't actually stuck on a decision — it was stuck on someone outside the company entirely: outside counsel, a partner, an official filing with its own clock. Items like that are still counted, but the metric deliberately never ages or alerts on them, because a countdown timer aimed at somebody else's calendar doesn't make them move faster. It just teaches everyone to stop trusting reds.

A queue that never says how long something has waited isn't a queue. It's a place where work goes to become invisible.

Five ways the metric was lying about itself before we caught it

None of this shipped on the first pass. Two review rounds — one automated, one a second look at the same code — found five separate ways the metric could have quietly misrepresented reality. Items that had already been proven overdue were being dropped from the count entirely, so a backlog could appear to be improving on the exact day it got worse. A text-search pattern used to find an item's origin was matching unrelated mentions of the same short name elsewhere in the history, inflating some ages with false matches. Outside parties named in parentheses were being discarded rather than recognized, which would have wrongly put them on the clock. A coverage flag that should have reflected "we only checked part of the fleet" was never being passed through, so the report implied full visibility when it had partial. And when an item's age genuinely couldn't be resolved, the code defaulted to treating that as fine — even though not knowing is worse than knowing, not better.

The second review round caught the sharpest one: if the whole data source came back empty — a malformed file, a moved document, a parsing regression — the metric read that as "the founder queue is clear" instead of "this tool can't see anything right now." That's the exact false all-clear the rest of the design exists to prevent, arriving through a door nobody had checked. All five are fixed. We'd rather a review catch a metric lying to us in a pull request than have it lie to us quietly for a month.

What we fixed ourselves, and what we left for a person to decide

Reading the real output also surfaced a few items sitting in the wrong bucket — counted as founder decisions when they were actually closed, externally blocked, or waiting on something as mundane as being physically at a specific machine. Two of those were unambiguous enough to fix directly: reclassified with the right external gate so they stop aging and stop inflating the count. Two more we left alone on purpose, because deciding whether a task is truly finished, or whether a location-based wait belongs in the same bucket as a legal one, is a judgment call — not something a script should quietly make on someone else's behalf.