Published August 14, 2026
This series has moved from the supply side to the demand side to the factory floor. The Software Foundry named the revolution: AI changes the production function of software. The App-Stack Tax named the waste on the buyer’s bill. Inside the Foundry walked the production system that removes it. But one part of the argument has stayed deliberately unfinished: if software is produced differently, what should it cost? A production revolution becomes economically important only when its gains reach the buyer. A faster factory that preserves the old price has improved the producer’s margin; it has not created an affordability revolution. The revolution becomes visible when the invoice changes — and, more importantly, when the changed invoice becomes the number every other producer must explain.
This essay names that number. And it is a number, not a product — which is what makes it the most contagious idea in the series.
The claim of this essay: markets do not change when one producer becomes cheaper. They change when buyers begin treating the cheaper price as normal. Manufacturing learned this as “the China price.” Software is about to learn it as the foundry price — and the most important property of a reference price is that it does its work in negotiations it never attends.
1
The Price Everyone Knows Before the Quote Arrives
The renewal arrives on a Tuesday afternoon, and it is rarely dramatic. The account manager has prepared the explanation before the buyer asks: the customer crossed a contact threshold; three more employees need access; a capability that used to sit inside the package has moved into a premium module; the annual increase is in line with the market. A discount is offered pre-emptively. The final number is close enough to last year’s to feel inevitable and large enough to require a meeting — and the meeting begins too late in the argument. Procurement debates the percentage. The business owner debates which modules to trim. Finance asks about contract length. Everyone negotiates around the quote, because everyone has accepted the invisible number beneath it: what software in this category is *supposed* to cost. The most powerful price in any market is not the amount printed on the invoice. It is the amount the buyer has stopped questioning.
Reference prices form slowly and then govern almost everything. A washing machine made in a high-cost economy is not judged against its own labour and materials; it is judged against the price the global factory system created. A technology project proposed entirely onshore is judged against the offshore rate even when no offshore supplier is in the room. A medicine whose exclusivity has ended is judged against the generic price however eloquently the branded manufacturer explains its history. In the early 2000s, Western manufacturing boardrooms learned the purest version of the pattern: “the China price” was not a quote from any particular factory — it was a number everyone knew before any quote arrived. And notice what it did not require. It did not require the buyer to move production to China; most never did. It did not require the Chinese producer to bid; it usually hadn’t. The number worked at a distance: once a credible alternative existed at a visible price, every incumbent quote had to be *justified* rather than merely *renewed*. Once the reference moves, the incumbent no longer describes its own economics in isolation. It must explain the spread.
The number does its work before any deal is signed.
Business software is the great exception — the largest spending category in the modern company with no reference price at all. Ask a finance director the market rate for a marketing suite, a service desk, or a workflow platform for two hundred people, and there is no number to give: only what the incumbents charge, which is a different thing entirely. The anchor in every software negotiation today is the vendor’s own last invoice; “market rate” means “last year, plus the uplift.” Discounting is theatre performed against a list-price fiction nobody has ever paid. What buyers have instead is a substitute that answers the wrong question — analyst quadrants and review sites that rank vendors by features and vision: comparisons of *what*, never of *what it should cost*. In no other major category does the seller supply both the price and the standard the price is judged against.
One clarification before the mechanism, because software has seen many low prices and very few price revolutions. Open source lowered the licence and moved integration and operation elsewhere. Freemium lowered the entry price and recovered the economics through upgrades. Venture-subsidised challengers entered below cost and raised prices once dependence formed. Those were changes in *commercial strategy* — and buyers learned, correctly, to distrust them. A reference price must be sustainable: it must remain true when the second product ships, the hundredth customer onboards, a connector fails at midnight and the support queue fills on a Monday morning. The foundry price qualifies for one reason only — it is a change in production possibility. The useful product can be made, operated and supported for less because less of it must be invented, repeated and manually carried each time. That is the difference between a cheap bid and a new normal.
2
How Software Escaped Its Cost Curve
To feel why the foundry price will land so hard, trace how software’s price became detached from its production curve — and begin with fairness, because the story is not one of villainy. The cloud bargain was real and overwhelmingly good. Before software-as-a-service, a customer bought licences, ran infrastructure, carried versions, hired specialists and absorbed long deployments; central operation removed most of that burden, and one product could improve continuously for every customer at once. The industry deserved a large share of that dividend. The question is what happened to the rest of it.
What happened was a doctrine — the most successful pricing doctrine in modern business, and it had a name: value pricing. Price the software not on what it costs to make and run, but on what it is worth to the customer. Reasonable on its face; software’s worth is real and often enormous. But notice what the doctrine quietly abolished: any relationship between the number on the invoice and the cost of the thing invoiced. Once price anchors to “value” — unmeasurable, negotiable, asserted by the seller — there is nothing for it to be compared *against*. Value pricing did not merely raise software prices. It removed the standard by which they could ever be questioned. The pricing grammar that followed acquired a peculiar direction: seats, contacts, events, orders, usage bands, editions — almost every sign of the customer’s success became a reason for the invoice to rise. The previous essay watched the merchant’s stack charge her for succeeding; the same mechanism lives inside the individual application, where the bill expands with the customer’s activity while the product performs essentially the same job on the same centrally operated system. The price became less a reflection of the work the software does and more a claim on the growth the customer creates.
The industry’s scoreboards then locked it in. Annual recurring revenue measured the base; net revenue retention measured how reliably the installed base paid more; customer-success organisations were built not only to preserve use but to locate expansion; packaging became a commercial architecture — enough value in the lower edition to enter, enough friction to make the next edition inevitable. None of it was foolish. It was the rational optimisation of a business whose delivery cost had collapsed and whose investors rewarded predictable expansion. The result was the strangest chart in modern economics: the cost of serving a customer falling towards zero while the price of being one rose every year — a gap with a respectable name, gross margin, and a public-market religion, NRR, that made widening it mandatory.
The cost of delivery fell towards zero. The price rose. Nothing forced them back together.
Why was this stable for twenty years? Because the cloud industrialised only half the problem. It industrialised *delivery* — and left *creation* artisanal. Every serious application still required a rare organisation: a team to discover the category, design the product, build identity and permissions, implement workflows, manage connectors, test releases, onboard customers and staff support. The marginal cost of serving another customer fell; the fixed cost of *becoming and remaining a software company* stayed high — and the successful vendor priced to protect the organisation built around that cost. The first essay named the deeper consequence in a different costume: the cost of creating software was the economic patent, and the patent protected more than the product. It protected the price. For a rival number to exist, someone had to build a credible alternative, and nobody could afford to — so no alternative price ever became visible, and the incumbent’s invoice remained the only number in the room.
The foundry attacks the neglected half. Specifications as control surfaces, proven components as tooling, inspection as software, operation AI-native — and the machinery compounding across products, so the second application does not have to buy a second company. When both curves fall — creation and delivery — the old reference price loses its final production defence, and the trillion-dollar repricing of software equities in early 2026 reads correctly at last: not a judgement about chatbots, but the market pricing in the death of a pricing regime — the end of the twenty-year vacuum in which no number ever questioned the invoice. The cloud made software recurring. The foundry makes its old price contestable.
3
What the Foundry Price Is — and How It Spreads
The phrase will be misunderstood unless its boundary is drawn sharply, so draw it from both sides. The foundry price is not the price of code. Code is becoming abundant, but customers do not buy code; they buy a dependable job completed over time — records that stay correct, permissions that hold, changes that do not break yesterday, support when reality finds the edge case. A repository can be generated in an afternoon. A product is a promise that survives contact with the world. So the foundry price *includes* the full cost of that promise: secure identity, tested behaviour, controlled releases, observability, backup and recovery, maintained connectors, documentation that stays aligned, AI-native support with human judgement for consequential exceptions. What it *removes* is everything the third essay showed being manufactured away: duplicated engineering — the same identity layer, workflow engine and connector framework rebuilt for every application; unused complexity — the accumulated features carried by customers who need the common job done well; and avoidable operating labour — the manual onboarding, the support agent asking for information the system already holds. The double Pareto cut, reaching the invoice: one cut removes feature waste, the other removes foundation waste, and the foundry price is what remains when both cuts land.
The definition: the foundry price is the lowest sustainable price for dependable, focused utility produced on reusable machinery. Lowest forces production discipline. Sustainable excludes subsidised theatre. Dependable preserves the trust floor. Focused rejects the bloated suite. Reusable machinery names the economic source. Remove any word and the phrase collapses into ordinary discounting.
Two honesty boundaries keep the definition serious. First, the foundry price is a licence price, not a total-cost guarantee: migration, integration, training and governance remain real and vary by customer; a foundry reduces them — the migration factory exists for exactly this — but it measures and publishes them separately, because a reference price that overclaims dies at its first audit, and the China price never claimed to include shipping. Second, not every category converges to the same ratio. Payments, systems of record, networks with deep liquidity, products built on irreplaceable data, software that underwrites consequential outcomes — that world holds value beyond repeated engineering, can stay expensive, and deserves to. The foundry price attacks the large exposed middle: mature code, understood workflows, accumulated features, and a premium protected mainly by the fear of leaving. In practice: arithmetic lands it at roughly one-tenth to one-fifth of the incumbent licence for the equivalent daily-use utility — with honest margin inside it. Price is the visible output. Production discipline is the warranty.
Now the mechanism — how a number becomes a market force. Three ingredients, and only three. A credible producer: at least one foundry delivering the useful core reliably in a category — not a demo; a running product with customers who stayed. A visible price: published, simple, self-serve — a number a finance director can screenshot into a board pack. A safe exit: migration measured in days and priced in advance, because a reference price backed by an unpriceable switching cost is a bluff, and procurement can smell a bluff. Assemble the three and the propagation begins:
Three ingredients — then the number spreads to negotiations it never attends.
The foundry price does its damage without a single customer switching. It enters renewals as the question the vendor must answer, board packs as the line that makes the current bill look strange, procurement as the benchmark. A market changes not when one producer becomes cheaper — it changes when buyers begin treating the cheaper price as normal.
And it will move faster than its manufacturing ancestor. The China price spread at the speed of trade shows, supplier visits and shipping lanes — a decade to become a boardroom fixture. A software reference price spreads at the speed of a pricing page: the moment one credible foundry publishes its number in one category, every buyer in that category can see it the same afternoon, and every renewal that quarter arrives with the number already in the room. The propagation infrastructure — comparison sites, procurement platforms, analyst notes, one viral screenshot — already exists and is bored. What manufacturing needed a decade to normalise, software can normalise in a renewal cycle or two.
4
The Incumbent’s Six Binds
The obvious question follows: why don’t the incumbents simply match it? They have the engineers, the customers, the data, the brand — and now the same AI models. They will certainly adopt the models: generate more code, automate support, ship simpler interfaces, launch AI features weekly. The mistake is to assume that access to the same technology creates access to the same economics. A new producer asks one question: what price can our production system sustain? The incumbent must ask a harder one: what happens to everything we already are if we admit that price is sustainable? Six binds, and they interlock.
Every response costs the incumbent something it cannot afford.
The valuation bind is the deepest, and a worked example shows why it travels backwards. Suppose the category leader sells at $100 and a foundry offers the common utility at $20. The leader can launch a $20 edition — but every existing customer using only the common utility now has a question, and the revenue risk is not confined to new deals; it propagates through the installed base, which is where the share price lives. Net revenue retention — the promise that existing customers pay more every year — collapses long before any challenger does. The cost bind: the organisation was built to be funded by the old price — enterprise sales, solution consulting, success hierarchies, twenty years of accumulated estate that must be operated precisely because it justifies the tiers; the price cannot fall without the organisation falling with it, which is why incumbents add AI to the product faster than they remove labour from the customer journey. Features are easier to change than organisations. The channel bind: a commissioned sales motion structurally cannot carry a product priced to need no salespeople; the people who would sell the new price are the people it makes redundant, and they know it. The completeness bind: the feature list is the pricing architecture — a focused, honest, cheap edition indicts the suite it sits beside, after years of describing breadth as value. The signal bind: a price cut is a confession that the old price was padding, and it invites the simultaneous renegotiation of the entire book of business — the one event a subscription company cannot survive. And the timing bind closes the cage: respond early and legitimise a challenger nobody had heard of; respond late and the reference price is already normal, at which point matching it merely confirms it.
The binds interlock, which is what makes them a trap rather than a list: escaping one tightens the others. Cut the price and the signal bind detonates; launch the honest edition and the completeness bind indicts the suite; build the separate low-cost brand — the one genuine escape — and the cost and channel binds fight it from inside the building, because the new unit’s success is, by construction, the old organisation’s obituary. None of this makes incumbents helpless: their trust, distribution, data and installed workflows are real, and some will navigate the transition — usually by becoming foundries themselves under separate brands, and usually only after the third bad quarter, because the innovator’s dilemma was never about ignorance; it was about permission. But the asymmetry is now precise. A lower tier is a product decision. A new reference price is a business-model decision. Features invite a roadmap response; price forces an identity response. The incumbent can copy the feature. It cannot easily copy the economics — because its economics are the thing its investors bought.
5
The Renewal Playbook
Everything above becomes practical at one moment: the renewal. So this part changes audience. It is written for the buyer — the founder, the finance director, the operations head with a contract expiring this quarter — and its advice fits in one sentence: negotiate as though the foundry price already exists. In some categories it already does; in the rest, its arrival is a matter of quarters. Seven questions, in order.
Seven questions to ask before signing.
One: which capabilities did we use every week this year? Not which features were enabled or demonstrated — which jobs would cause real pain if removed tomorrow. Pull the usage report; the vendor has it, and reluctance to share it is itself an answer. The answer is usually shorter than the contract — and know the difference between optionality you value and complexity you merely carry: paying for a fire extinguisher is rational; paying for an entire fire brigade inside every room is not. Two: what is the price connected to? If the honest answer is “your headcount and your contacts” rather than “our cost to serve you,” then your growth is being taxed — separate genuine variable cost from a convenient staircase; a contact sitting unused in a database does not cost the vendor what the tier jump charges for it. Three: what does this year’s uplift buy that last year’s did not? An uplift justified by a roadmap you never requested is a habit, not a price. Four: has anyone priced leaving? In most companies the switching cost is a fear, not a figure. Get a migration quote even with no intention of migrating — the moment leaving has a price, staying has a negotiation. Five: what value sits beyond the code? This question protects you from simplistic price aggression: network effects, irreplaceable data, regulatory trust, underwritten outcomes can justify a real premium. The test that separates them from padding: what would remain defensible if migration became safe, common and reversible? Dependence is not the same as value, though it often stands beside it. Six: will the vendor price the used core, alone? The revealing question — a vendor who refuses to quote the fifteen per cent you use is telling you what the other eighty-five per cent is for. Seven, the anchor: if a focused alternative existed at one-tenth the price, what would we pay to stay? Answer it internally, in a number, before the meeting — then negotiate from that number rather than from last year’s invoice. The vendor’s anchor is history. Yours should be the future.
The output of the seven questions is a one-page renewal memo with four numbers on it: the used core, the growth tax, the exit price, and the anchor from question seven. Four numbers, one page — and the meeting is a different meeting, because for the first time both sides arrive with a standard of comparison. Two disciplines keep it honest: this is not advice to buy the cheapest thing — the series’ standard is trusted affordability, and a good incumbent will have answers where a vulnerable one has packaging; and the playbook serves something beyond any one bill. Every buyer who makes the vendor explain the price against the used core is helping construct the reference itself, the way every manufacturer who asked about the China price helped make it a fact. Reference prices are not announced. They are asked into existence, one renewal at a time.
6
When the Price Falls, the Market Expands
Price revolutions are usually described as wars over an existing pool of customers: the entrant undercuts, the incumbent bleeds share, industry revenue shrinks. That is the first-order view, and it is the least interesting thing that happens. The deeper pattern, every time, is expansion. China’s factories did not merely move the same purchases to cheaper suppliers; lower prices put appliances and electronics within reach of hundreds of millions who had never been customers. India’s delivery machine did not only replace onshore projects; it made technology work viable that would otherwise have been deferred forever. Generic medicines did not change the supplier; they changed who could be treated. The market after every reference-price reset was larger than the market before it.
Software is unusually ready for the same effect, because its non-consumption is invisible. The clinic coordinating through spreadsheets, the school running on messaging groups, the manufacturer whose workflow lives in one employee’s memory, the merchant whose customer database is a phone’s contact list — none of them appears in any vendor’s lost-deal report. They did not choose a competitor. They were never candidates at the old price and the old operating burden. The foundry changes all four terms that excluded them at once: creation becomes cheap (the machinery is reused), distribution stays near-zero (the cloud solved it), onboarding and support become AI-native (no consultant required to begin), and narrow categories become viable (no product must fund a complete software company). The addressable market expands downwards in company size and outwards into languages, local practices and specialised jobs.
The market after the reset is larger than the market before it.
The arithmetic that looks alarming is the arithmetic that matters. A product at one-fifth the price needs five times the customers for the same revenue — and conventional analysis stops there, which is why conventional companies will not do this. Foundry analysis continues: can the production system serve ten times the customers at far below one-fifth the total cost, when onboarding, support and operation scale with machinery rather than headcount — and how much of that volume is revenue that did not exist before? Add the portfolio effect from the third essay: a narrow workflow for one profession is too small to justify a standalone company and entirely viable as the seventh product in a foundry, where localisation and category logic sit on already-paid-for tooling. Lower price and larger market build a larger company, not a smaller one — which is the difference between discounting and abundance. Discounting asks how much less a seller will accept for yesterday’s product. Abundance asks what becomes possible when the cost structure itself changes.
One warning closes the argument, because the trap ahead is the industry’s oldest. Successful foundries will feel the pull of the old climb: win with affordability, add features, move upmarket, build the sales and services organisation — and discover, a decade on, that the reference price they disrupted has quietly reassembled itself inside them. The discipline must survive success: products thin, machinery strong, usage transparent, premium reserved for value that truly sits beyond code. The foundry price is not a launch tactic. It is a constitutional constraint. And when the constraint holds, the most important customer is not the enterprise that saves eighty dollars. It is the small business that can finally spend twenty; the specialist whose narrow workflow finally supports a product; the merchant who moves from messages and memory to a dependable system. The affordability dividend is not that today’s buyers pay less. It is that tomorrow’s buyers finally exist.
Closing: When the Revolution Reaches the Invoice
The series can now be stated in one line: a production revolution (the foundry) removes a category of waste (the app-stack tax) through a machine (specifications, tooling, industrialised quality) — and transmits itself to the entire market through a number. The number is the final piece and the most contagious one: products must be adopted one customer at a time, but a reference price, once credible and visible, changes the behaviour of buyers who never adopt anything. It will not arrive everywhere at once; some categories hold value beyond code and will keep their premium with justification; some challengers will fail by confusing generated code with a dependable product; the reference will form through evidence — products that stay reliable, migrations that become safe, portfolios in which every product makes the next cheaper. Including, as the previous essay promised, evidence of our own, published favourable and unfavourable alike.
But once the evidence accumulates, the market’s question changes permanently. Buyers stop asking whether the new product is suspiciously cheap and start asking why the old one is inexplicably expensive. Vendors will not have to lose a deal to feel it; they will simply, one renewal at a time, have to explain a number they never had to explain before. The quote will no longer begin the negotiation. The reference price will.
**
The old software price was built on scarcity: scarce engineers, repeated foundations, large operating teams. The foundry price is built on abundance — abundant code disciplined by specifications, reusable machinery, industrialised quality, and human judgement concentrated where consequence demands it.
A market changes not when one producer becomes cheaper, but when buyers begin treating the cheaper price as normal.
The software foundry changes how software is made. The foundry price is what happens when the revolution reaches the invoice.
