Stop measuring output. Start measuring outcomes the company can’t forget.

A sales team ships forty proposals in a quarter and the dashboard turns green. Activity is up, the burn-down looks healthy, everyone gets a nod in the all-hands. Nobody in the room can tell you which of those forty actually closed, which approach won, or whether sending forty was the reason for the wins or just noise around three that would have closed anyway. The number that got celebrated, forty, is the one number that doesn’t matter.

We measure what’s easy to count, and what’s easy to count is motion. This post is about the gap between motion and result, and the one thing a company needs to finally close it.

An OS that remembers every decision and its result lets you grade the outcome, not the activity.

Why companies measure output in the first place

It isn’t laziness. It’s physics.

Output is the only thing visible in the moment a thing happens. The proposal got sent, you can see it leave the outbox. The ticket got closed, the call got made, the feature got merged. Each of those is a discrete, timestamped, countable event, and you can put it on a chart before lunch. The outcome, did the proposal win, did the closed ticket actually fix the customer’s problem, did the feature move the metric it was built to move, arrives weeks or months later, in a different system, told by a different person, if anyone bothers to connect it back at all.

So we grade the part we can see. Not because activity is what we care about, but because activity is what’s in front of us when the grading happens.

Output is what you can count today. Outcome is what you’d actually care about, if you could still remember today by the time it arrives.

That last clause is the whole problem. By the time the outcome lands, the decision that caused it has fallen out of the company’s memory. The proposal that won was the eleventh one this quarter; nobody remembers what made it different. The pricing change that lifted conversion shipped in March; by June the person who argued for it has moved teams and the reasoning lives in a closed thread nobody will reopen. The cause and the effect exist, they just never get held in the same hand at the same time.

The naive fix: measure harder

The obvious response is to count more carefully. Better dashboards. More metrics. An OKR per team, a north-star number, a weekly business review where everyone reports their figures.

It feels rigorous. It produces binders.

Here’s where it fails. More dashboards measure more output, they don’t connect output to outcome, because the connection isn’t a measurement problem. It’s a memory problem. You can chart proposals-sent to four decimal places and still have no idea which template won, because “which template” was a decision made in a hurry, in a doc, by someone who didn’t tag it, and the win came in eight weeks later through a CRM field nobody links back to the doc. The two facts live in two systems with no thread between them. Counting harder on either side doesn’t grow the thread.

So companies do the expensive thing instead: they assign a human to be the thread. An analyst, a chief of staff, a founder at 11pm, manually walking backward from a result to the decision that caused it, reading old messages, reconstructing who decided what and why, stitching the cause to the effect by hand. It works, sort of, for the three decisions important enough to investigate. The other nine hundred decisions a company makes every quarter go ungraded, because there is no human-hours budget to trace them all. The outcome of almost everything you do is simply never measured against the choice that produced it.

An OS that remembers every decision and its result lets you grade the outcome, not the activity.

The real fix: a system that holds the whole loop

The reason output is easy and outcome is hard has nothing to do with the metrics. It’s that no single system in the company is present for both ends of the loop, the decision and its result, and remembers the first one is still around when the second arrives.

That’s not a dashboard. That’s an operating system with memory.

Consider what it would take, concretely. When a proposal goes out, something records not just that it left, but which version it was, what was different about it, who decided to send that one, and what they expected to happen. That last field, the expectation, is the one nobody writes down today, and it’s the one that makes a grade possible later, because a result is only good or bad relative to what you were betting on. Then weeks later, when the deal closes or dies, the same something connects that result back to the original choice, automatically, while you sleep, and now the decision has a grade attached to it that no human had to reconstruct. Multiply that by every proposal, every pricing change, every feature, every hire, every market entered. The company stops forgetting the cause by the time the effect shows up.

None of those four steps is hard on its own. Recording a decision is a write. Storing it is a row. Watching for the result is a query. Matching them is a join. The reason no company does it isn’t that any single step is difficult, it’s that doing all four, for every decision, forever, without a human dropping the chain somewhere in the middle, is precisely the kind of patient, unending bookkeeping that people are bad at and an always-on system is good at. The hard part was never any one link. It was keeping the chain unbroken across months.

The key idea is simple: you can only grade outcomes if one system remembers the decision long enough to see how it turned out. The whole feat is the remembering.

Memory is the primitive, not the dashboard

A dashboard is a view. It shows you the state of things right now. The moment “now” passes, the dashboard repaints and the old state is gone, which is exactly the wrong shape for grading outcomes, because the thing you need to grade happened in the past.

What you need underneath is a memory that doesn’t repaint. A durable record of every decision the company made, what was chosen, by whom, why, and what it was supposed to achieve, that stays addressable months later when the result finally arrives. The dashboard sits on top of that memory and becomes something new: not a snapshot of activity, but a ledger of decisions waiting to be graded by their results.

The loop has to close itself

Here is the part a human can’t sustain. Closing the loop, walking from a result back to its cause, is unglamorous, never-finished work, and a person will do it for the three decisions that hurt enough to investigate and quietly skip the rest.

A system doesn’t get tired and doesn’t triage. When a result lands, it can match it back to the decision that caused it the same way every time, for the nine-hundredth decision as faithfully as the first. The grading stops being a heroic quarterly investigation and becomes a thing that’s just always true: every decision in the company carries its own outcome, attached, because the system that watched the decision was still watching when the result came in.

An OS that remembers every decision and its result lets you grade the outcome, not the activity.

What changes when outcomes are the unit

Grade outcomes instead of output and the incentives invert in a way you can feel within a quarter.

When activity is the metric, the rational move is to do more things. Send more proposals, ship more features, book more calls, because the chart rewards the count. Half of that motion is waste, but the waste is invisible, because nothing ever connects the forty proposals back to the three that mattered. You optimize for looking busy, because busy is what’s measured.

When the outcome is the metric, the rational move flips: do the things that worked more, and the things that didn’t, less. The proposal template that wins gets reused because the system remembered it won. The pricing experiment that flopped gets retired because its result got matched back to the decision, instead of quietly persisting because everyone forgot it was an experiment. You stop rewarding motion and start rewarding the small number of decisions that actually moved something, which, it turns out, was the entire point of measuring at all.

The turn

Why does any of this matter to the person reading it?

Because if you’re a founder, you are currently the company’s memory of why things were decided, and you are losing that fight every single day. You remember the reasoning behind the big calls for a while. Then the company makes its next thousand decisions, and the old ones blur, and the result of choice number 312 comes in and you genuinely cannot recall what you were thinking when you made it. So you grade your company on output, like everyone else, not because you believe activity is the goal but because outcome requires a memory you no longer have the bandwidth to be.

Move that memory off your head and onto a system that holds every decision until its result arrives, and something quiet happens. You stop being the company’s filing cabinet for why. You get to be the person who decides which outcomes are worth chasing in the first place, what “won” should even mean, which results are worth the company’s attention, what kind of company the grades are slowly turning yours into. That judgment was always the work only you could do. It was just buried under the job of remembering everything, which was never work you were good at, and never work you should have had.

---

That’s what we’re building at Apollo Space: an operating system that remembers every decision and the result it produced, so the company grades itself on what actually worked instead of how much it moved. The numbers on your dashboard will get smaller and start meaning more. And the part of you that has been holding the whole story together in your head gets to put it down, and finally just decide where to point the thing.