When labor is software, the P&L stops looking human

Open the income statement of a 20-person services firm and you can read the whole company in two lines. Salaries, the biggest number on the page. And revenue, which grows only when that biggest number grows too. To sell more, hire more. The P&L is honest about it: the cost of the work and the people doing the work are the same thing.

Now do the same work with software, and that statement stops making sense. The largest expense no longer scales with headcount. It scales with usage. And it stops sitting where it used to sit on the page.

The financial statement of a company is about to stop looking like a 20th-century one, not because the numbers get bigger, but because the lines move.

The refrain: payroll is becoming a usage bill

Here is the load-bearing idea, and we’ll repeat it until it stops sounding strange. When labor is software, payroll stops being a fixed cost that scales with headcount and becomes a variable cost that scales with output.

That is not a budgeting tweak. It rewrites the grammar of the income statement. The line that used to be the most predictable number in the company, salaries, paid monthly, fixed regardless of how much got done, becomes the most usage-shaped number in the company. It moves up or down with the work, not with the hiring plan.

Here’s why that single change drags the rest of the statement with it.

Where the work cost used to live, and why that was a lie

Start with how accounting has always carved up the cost of work.

The naive mental model, the one most operators carry, is that there are two kinds of cost. There’s the cost of making the thing you sell, which sits up top as cost of goods sold (COGS), gets subtracted from revenue, and gives you gross margin. And there’s the cost of running the company, sales, management, the office, most of the salaries, which sits lower as operating expense (opex).

For a software company, that split was clean. The servers that run the product? COGS. The engineers who built it, the salespeople, the founders? Opex. Labor lived almost entirely below the gross-margin line, in opex, because human labor built the product but didn’t deliver each unit of it. You wrote the code once; the marginal cost of one more user was a sliver of cloud bill. That’s why software gross margins are famously high, the people aren’t in COGS.

For a services company, the split was a quiet fiction. The consultant’s salary technically delivers the service, so a chunk of payroll really is COGS. But it gets reported as one big opex blob anyway, because nobody wants to tag every hour. So the statement says the labor is overhead when economically it’s the product. The cost of the work and the cost of the company got mashed into one line because separating them by hand was too much work.

The split survived for forty years for one reason: labor was lumpy. You hired a person in whole units, paid them whether or not the work showed up that month, and couldn’t meter their output by the task. A salary is a fixed cost because a human is a fixed cost. So it sat in opex, fixed, and you reasoned about it as a fixed cost because that’s what it was.

What breaks when the worker is metered

Now make the worker software, and watch the assumption underneath the whole layout fall out.

A software worker is not lumpy. It is not hired in whole units, it is not paid when no work shows up, and its output is metered, by the task, the token, the run. You don’t pay for a coworker’s month. You pay for the work that was actually done. The cost arrives attached to the output that caused it.

Once that’s true, every reason payroll lived in fixed opex evaporates at once.

It’s no longer fixed: the bill is zero on a quiet day and large on a busy one, because nothing is on salary. It’s no longer headcount-shaped: you don’t add a “person,” you add capacity that bills by use, so the cost curve bends with demand instead of stepping up when you hire. And, this is the part that reshapes the statement, it’s no longer cleanly overhead, because when a software worker handles a customer onboarding or drafts the deliverable, that cost is the cost of delivering the unit you sold. It belongs above the gross-margin line. It belongs in COGS.

So the payroll line doesn’t just shrink or move. It splits and migrates. The portion of labor that delivers the product walks up the page into COGS, metered per unit. The portion that builds the company, the taste, the direction, the relationships, stays in opex, where the remaining humans are. The single fixed salary blob becomes two flows: one variable and unit-attached, one fixed and human.

When labor is software, payroll stops being a fixed cost that scales with headcount and becomes a variable cost that scales with output. That sentence, drawn on the statement, is a line crossing from below the gross-margin rule to above it.

Gross margin starts behaving like a product’s

Here’s where it gets interesting for anyone who has ever modeled a company, because the consequence lands on the one number investors stare at: gross margin.

The naive expectation is that automating labor makes margins go up and stay up, software margins, 80-something percent, the dream. Suppose a services firm replaces a chunk of delivery labor with software and watches gross margin climb. The story writes itself.

But that’s not quite what happens, and the difference matters. The labor didn’t vanish from the cost of delivery; it changed shape. It moved into COGS as a variable, per-unit cost. So gross margin stops being a fixed property of the business and becomes a function of unit cost, exactly like a product company’s. If each delivered unit carries, say, a few cents of model and compute cost, your margin is now a curve that depends on how efficiently each unit runs, how much the underlying compute costs that quarter, and how much work each customer actually pulls.

That cuts both ways, and honesty requires saying so. A services business that used to live and die on utilization, are my people billable enough hours?, gets to trade that for something closer to a product’s economics: the cost scales down to near nothing when no one’s using it, and the margin on the next unit is mostly clean. That’s the upside, and it’s real.

The downside is that the floor under your margin is now somebody else’s price. The cost of the work tracks the cost of the underlying compute, which you don’t set. A services firm never had to care what a unit of delivery cost at the infrastructure level, because the unit was a salaried human and the cost was fixed. A software-labor firm cares a great deal, because the unit is metered and the meter belongs to a supplier. Your COGS has a dependency it never had before.

So the right way to read the new statement isn’t “margins went up.” It’s “margins became a function instead of a constant.” The number you used to assume is now a number you have to engineer.

The line that disappears: headcount

There’s one more change, and it’s the one that will feel strangest to anyone who has run a company, because it removes a number that used to be the company.

Headcount was never just a cost input. It was the proxy for everything, capacity, ambition, valuation, how seriously to take you. “We’re 40 people” told an investor more than any single financial line. The org chart and the payroll schedule were the same document read two ways.

When the work is software, that proxy comes apart. The thing you used to measure with headcount, how much work the company can do, no longer correlates with how many people you employ. A company can take on a season’s worth of new work without a single new salary on the books, because the new capacity arrives as usage, bills as usage, and shows up in COGS, not in a hiring plan. The “how big are you” question stops having a headcount answer.

That’s not a smaller company pretending to be a bigger one. It’s a statement that finally separates two things that were always different and only ever got conflated because labor was lumpy: the size of the work and the size of the team. On the old P&L they were one line. On the new one, the work lives in COGS and scales with revenue, and the team lives in opex and scales with judgment. They are allowed to grow at completely different rates, and for the first time, the statement shows it.

The turn: the statement was always a mirror

Strip away the accounting and here’s what’s actually happening.

For a century, the income statement told one story about what a company is: a building of people, where to do more you employ more, and the proof was right there in the salary line, the biggest, most fixed, most human number on the page. We read the statement and saw the people. The structure of the document encoded the structure of the firm.

When labor becomes software, the statement starts telling a different story about what a company is, and it’s a better story, if you’re willing to read it. It says the work is no longer the same thing as the people. It says capacity is something you can buy by the unit instead of by the hire, so the company can take on more without becoming heavier. And it says the humans who remain on the page aren’t there to do the volume of work, they’re there to decide what work is worth doing, what “good” means, who to serve and how. The salary line shrinks not because people matter less, but because the few people left are doing the one thing the software can’t: choosing.

When labor is software, payroll stops being a fixed cost that scales with headcount and becomes a variable cost that scales with output. Read it one more time and notice what it frees. It means a company is no longer something you grow by adding mass. It’s something you grow by adding work, and the people stay small, and senior, and pointed at taste.

That’s the statement we’re building Apollo to produce: one where the work of the company runs as software metered by output, the cost lands honestly where it’s incurred, and the line that used to read “salaries” reads, instead, “the few humans deciding what the company should chase.” The P&L was always a mirror of how the work gets done. The work is changing. The mirror is about to show somebody new.

---

If you’ve ever stared at a payroll line that grew every time the work did and wondered whether that was a law of nature or just an artifact of slow humans, it was the second one. This is what we’re building at Apollo: the operating system that lets a small, sharp team run a company whose income statement finally tells the truth about where the work happens.