With AI agents, the first version of almost any internal tool ships in days. That has made one part of software cheap, writing it, and left the other part almost untouched: keeping it running, secure and current for years. Anyone deciding between building and buying on the first part alone gets it wrong in both directions. They build things they should not be maintaining, and they keep paying for licences covering work they could now do better in-house.

What has become cheap and what has not

The cost of going from an idea to a working version has collapsed. A small team with a good specification produces in a week what used to take a quarter, and the quality of the result depends more on the precision of the request than on headcount. I cover this in more detail in the piece on spec-driven development.

What comes afterwards has not moved. Dependencies need updating, integrations break when the other side changes its API, auditors ask for traceability, users find cases nobody anticipated, and the person who built it moves to another role. That cost of ownership used to be a small share of the total because building was so expensive. It is now the largest share, and it is exactly the part that never shows up in the demo.

The happy path and the edge cases

The usual rule is that the happy path, the flow where everything goes as expected, covers 80% of transactions with 20% of the effort. It is what shows up in the demo and what an agent builds in days. The rest of the effort goes into edge cases: a partial return on an order shipped in two parcels, a customer with two tax entities, a price change mid-period, an invoice in another currency. They are few in volume and expensive in consequences, because that is usually where the money, the regulatory risk or the important customer who gets angry sits.

A mature SaaS product is largely an inventory of edge cases solved over years and thousands of customers. Comparing the licence price with the cost of building the demo version compares the whole product with its 20%.

The argument cuts both ways. A SaaS vendor carries the edge cases of all its customers, and most of them do not affect you. An in-house tool only has to solve yours. The decision turns on that inventory: if before building you can write down your edge cases and the list is short and stable, building pays off; if it is long, changes often or nobody can write it, buy. If nobody in the company can list them, that is a problem in itself, whether you build or buy.

When building in-house pays off

Building pays off when three conditions hold at once. First, the software encodes how the company competes: pricing logic, stock allocation, risk criteria, the workflow that makes a customer prefer you. If the process is the same as your competitors’, building it gives you nothing the licence did not already give you. Second, the scope is narrow. A tool that solves one specific problem well is cheap to maintain. One that tries to replicate a whole product inherits every edge case without the customer base that pays for handling them. Third, there is a named owner who keeps answering for it once the project stops being new.

When the third condition is missing, the pattern repeats. Month one goes well, by month six nobody remembers why a decision was made, and by month eight there is a critical system nobody wants to touch. Cheap code does not prevent this. It speeds it up, because more things get built in less time.

When to keep buying

Buying still wins clearly in four cases: systems of record such as accounting, payroll or ERP, where a mistake has legal consequences and accumulated reliability is worth more than any customisation; anything carrying regulatory weight, because the vendor takes on part of that responsibility and spreads it across thousands of customers; anything that depends on integrations with many third parties, where maintaining those integrations is the real product; and any process that does not differentiate.

For most companies the likely outcome is not replacing their SaaS but thinning it. They buy the core and build on top the layer they used to request from the vendor as an add-on module, custom development or extra seats. That is where cheap code returns the most at the lowest risk, because the system of record stays with the vendor and what is built in-house is small, specific and replaceable.

What defends a SaaS business when features are cheap to copy

For vendors the consequence is uncomfortable. The feature list, which for fifteen years was the main barrier to entry, no longer protects anyone, because it is exactly what a customer or a new competitor can replicate in weeks.

Four defences remain that cheap code does not copy. The first is accumulated data and solved edge cases: a product that has learned from thousands of customers over years offers something a freshly built internal tool cannot have. The second is network effects, where the value to each customer grows with the number of customers, suppliers or users connected. The third is taking on the customer’s regulatory responsibility: certifications, audits, sector compliance. The fourth is being so embedded in the workflow, with so many integrations and so much process built around it, that rebuilding costs more than the licence saves.

Pricing is the second front. Per-seat pricing has little future when agents do part of the work that used to justify each seat, because the customer who automates pays less while getting more value. SaaS businesses that move to pricing by outcome, volume processed or decision made align revenue with what the customer values. Those that stay on per-seat pricing will see revenue fall precisely in their most advanced customers.

Which SaaS businesses should not try to defend

For some products the honest answer is that defending as a standalone product makes no sense. These are horizontal tools priced per seat, with little proprietary data, used by a single team, solving something an agent with access to the customer’s systems already handles reasonably well. Adding AI features does not save them, because the customer can add the same features on their own.

They have three rational exits. They can become the system of record for a specific niche and trade breadth for depth. They can fold into a larger platform that gives them distribution and data. Or they can sell while their growth metrics still support the valuation. Spending two years in a feature race against their own customers is the option that ends worst.

The question to ask

For buyers, the useful question is no longer whether something can be built, because it almost always can. The question is who will own that software three years from now and what the company loses if that person leaves. For vendors, the question is which part of the product would still be hard to rebuild if the customer had a free engineering team tomorrow. That part is the business. The rest is copyable features.