The subscription was the wrong unit

Last quarter you bought a tool for fourteen people. Eleven of them opened it twice. The software billed you the same whether a seat closed a deal or never logged in at all. At renewal, the vendor showed you a usage chart, congratulated you on your “adoption,” and asked for a bigger number. You paid it, because the alternative was ripping out a thing that three people genuinely needed. That is the seat model working exactly as designed, and it is the clearest sign that the unit you’ve been buying was never the unit you wanted.

You weren’t overpaying for seats. You were paying for the wrong thing.

That sentence is the whole post, and the rest is the mechanism. Because “outcome-based pricing” is the kind of phrase a sales deck throws around to mean nothing, and we want to say exactly what the right unit is, why software priced itself by the seat for forty years, and what changes the day the unit becomes the work instead of the worker.

What a seat actually prices

A seat is a strange thing to sell. Strip the branding off it and a per-seat license is a bet: the vendor is betting that access correlates with value. Give a human a login, the theory goes, and that human will do something worth paying for. So you pay for the login.

The bet was reasonable for one reason. For most of software’s history, the software couldn’t do the work. It could only help a person do the work. Word processors, spreadsheets, CRMs, design tools, every one of them was a lever, useless until a trained human picked it up and pulled. The value lived in the human. The software was the handle. Pricing the handle by the hand that held it made a rough kind of sense.

A seat prices access to a tool. It assumes the human is still the one doing the work.

So the whole industry standardized on it. Per-seat, per-month, billed annually, true-up at renewal. It became so normal that we stopped seeing it as a choice. It felt like the natural shape of software pricing, the way water is the natural shape of its glass.

Here is the part nobody says out loud: the seat model only works if the human is the bottleneck. The moment the work can happen without a human in the chair, you are paying for an empty chair.

The naive fix, and why it fails

The obvious response, the one every procurement team reaches for, is to count better. If you’re overpaying for seats, audit the seats. Pull the usage report, find the eleven dormant logins, downgrade at renewal, claw back the spend. Tighten the belt.

We’ve watched teams run this play for a full quarter. It feels productive. It is not.

Counting seats more carefully optimizes the wrong number. You’re still pricing access, you’ve just bought less of it. The dormant login wasn’t the disease; it was a symptom of a pricing unit that was never tied to anything you cared about. A firm doesn’t want logins. It wants the invoice chased, the lead qualified, the contract reviewed, the report out the door by Friday. None of those are seats. You can run a perfect seat audit and still be paying, precisely, for the wrong thing.

The deeper failure is that the seat model actively punishes the outcome you want. Imagine a tool so good that one person, leveraging it, does the work that used to take five. Under per-seat pricing, you just cut your own bill by eighty percent, so the vendor’s incentive is the opposite of yours. They need more chairs filled, and you need fewer chairs to matter. The pricing unit puts the buyer and the seller on opposite sides of the table on the one question that counts: did the work get done?

You weren’t overpaying for seats. You were paying for the wrong thing. Counting the seats more carefully doesn’t fix a unit that measures the wrong quantity, it just measures the wrong quantity twice.

The unit that was always hiding under it

So what is the right unit? It’s the one the seat was always a proxy for. Not access to a tool. The work the tool was supposed to get done.

The reason we never priced the work directly is that we couldn’t isolate it. Work and worker were fused. There was no way to point at a finished outcome and say “the software did that part”, because the software hadn’t done any part of it; a person had, with the software as a lever. You can’t bill for an outcome you can’t attribute. So we billed for the lever and hoped the outcome followed.

That constraint is the thing that just changed.

When the system can do the work, read the inbox, qualify the lead, draft the contract review, chase the invoice, and hand you the result, the outcome becomes a thing you can finally point at. There’s a discrete unit of work with a beginning and an end: a task picked up, carried, and finished. You can count those. You can price those. For the first time, the unit you buy can be the unit you actually wanted all along.

Think about what that does to the renewal conversation. The vendor no longer arrives with an adoption chart and a bigger seat count. They arrive with a ledger of work completed, invoices chased, leads qualified, reviews turned around, and the bill tracks it. If the work doesn’t happen, the bill doesn’t grow. The buyer and the seller are finally reading the same number off the same page, and that number is the one the buyer cared about from the start.

Price the work, not the worker. The unit was hiding under the seat the whole time.

Why this only becomes possible now

It’s fair to ask why, if the work was always the thing we wanted, nobody priced it that way before. The vendors weren’t fools. They priced by the seat because, for forty years, the seat was the only thing they could honestly measure.

Outcome pricing has a hard prerequisite: the seller has to be able to deliver the outcome, not just the access. A spreadsheet vendor cannot promise your model is built, only that you can open the file. A CRM cannot promise the lead is qualified, only that there’s a field to type it into. Selling an outcome you can’t produce is just a refund waiting to happen, so vendors sold the honest thing: access. Per-seat wasn’t greed. It was the truthful unit for software that could only assist.

The moment software can carry a task end to end, the honest unit changes with it. Now the vendor can stand behind the outcome, because the system is the one producing it. The thing that made outcome pricing impossible, software’s inability to finish anything on its own, is exactly the thing that just stopped being true. Keeping the seat model after that isn’t prudence anymore. It’s billing for a constraint that no longer exists.

And notice the alignment it creates, almost as a side effect. When you pay per outcome, the vendor’s only path to more revenue is to get more of your work done. Their roadmap bends toward your results, because that’s where their bill comes from. The seat model asked you to trust that the vendor wanted you to succeed. The outcome model removes the need for trust, it wires the vendor’s incentive straight to your finished work.

You weren’t overpaying for seats. You were paying for the wrong thing. The right thing only became purchasable when software could finally produce it.

What this looks like from the buyer’s chair

Let’s make this concrete, because the shift sounds abstract until you sit in the buyer’s seat at renewal.

Under the old unit, your spend was a function of headcount and hope. You bought a block of seats sized to your team, watched most of them sit idle, and renewed on faith that the access was worth it somewhere. Your cost grew with the size of your org and had almost nothing to do with how much got done. A growing bill was a sign of a growing payroll, not a growing output.

Under the new unit, spend is a function of work completed. A quiet month costs less because less happened. A heavy month costs more because the system carried more, and you can see exactly what it carried. The bill stops being a fixed tax on your headcount and becomes a variable cost tied to throughput, the way you’d want any input to behave. You’re no longer buying the capacity to maybe do work. You’re buying the work.

This is why the framing matters more than the discount. A buyer who negotiates a cheaper seat is still trapped in the old unit, just paying a little less to be measured by the wrong thing. A buyer who switches units stops measuring access entirely and starts measuring results. One is a better deal on the wrong purchase. The other is the right purchase.

The turn

Run this all the way out and something uncomfortable surfaces, and it isn’t about pricing at all.

If you’ve been paying by the seat, you’ve quietly been pricing your people the same way, as access points, as logins, as capacity that may or may not get used. The seat model didn’t just mismeasure your software bill. It trained a whole generation of org charts to value the chair over the work, to confuse “we hired five people” with “five people’s worth of work is getting done.” Those were never the same sentence. The seat model just let us pretend they were.

Move the unit to the work, and the question you ask about a person changes too. It stops being “do they have a seat” and becomes “what did we get done, and what did it cost to get there.” That’s a better question to ask about software. It turns out to be a much better question to ask about a company. And it points at the one thing no pricing model can buy for you: deciding which work was worth doing in the first place. The system can finish the task. Only you can choose which tasks deserve to exist.

That choice was always the high-leverage part of your job. The seat model kept it buried under the low-leverage work of staffing chairs and justifying logins. Price the work instead, and that buried choice is the thing left in your hands, which is exactly where it belonged.

---

That’s what we’re building at Apollo Space, software priced by the work it finishes, not the chairs it fills, so your bill finally tracks the only thing you were ever trying to buy. If your renewals have started to feel like a tax on access nobody uses, that feeling has a name now. You were paying for the wrong unit. It’s time to pay for the work.