The cost of the carry

Code was never the hard part of software. The hard part has no demo: the integration with three other systems that already hold your data, the permissions model deciding who sees what, the audit trail a regulator or acquirer will eventually ask for, and the edge cases nobody specified until they broke something. None of that shows up in a weekend prototype. All of it shows up later, as a recurring obligation instead of a one-time cost.

Context decay. The person who built the tool understands it completely on the day they build it. Six months later, nobody understands it, because none of that reasoning was ever written down anywhere durable.  

The integration surface. Every internal tool touching real company data opens a surface you now own and must defend: authentication, access control, logging, data residency, and single sign-on. A vendor carries that cost today. Build the replacement, and the cost doesn't disappear; it moves onto your own balance sheet, usually unfunded.  

Attention. In a fifty- or two-hundred-person company, the scarcest resource in the building is leadership's capacity to make decisions. Every hour spent wondering whether the internal tool is computing the right number is an hour not spent on work that compounds.  

Feature gravity. Internal tools don't stay the size they were on the day they were born. People ask for changes, the list grows, and the person who built it becomes a part-time product manager for a product that doesn't generate revenue.

One question does the work of the whole framework

If the person who built this left tomorrow, what happens?  

If nothing happens, someone deletes it and the business moves on. Build it, ship it, forget it. It was never a product, just a means of convenience.  

If the company had to reverse-engineer the thing and rebuild it from scratch, that's a vendor-shaped hole. The fee you resent is the price of not carrying the obligation yourself, and even Leach's conservative math shows the fee usually beats the carry.  

If critical workflows would break and nobody could fix them, the decision already got made badly. The only useful move left is fixing it before the failure arrives on its own schedule instead of yours.

The SaaS trap, made concrete

Strip away the market drama, and the trap enterprise software buyers have lived with for two decades is simple, and it's the same trap on both sides of build vs. buy. Per-user licensing compounds year over year, typically eight to twelve percent annually, as a permanent drag on margin that has nothing to do with whether you use more of the product. The vendor owns the software and the data model and controls the roadmap, the pricing, and the deprecation schedule on their own timeline, not yours. The product is generic by construction, built for the average of a thousand customers, so your team bends its workflow around the tool instead of the other way around. Your data sits in the vendor's schema, with real switching costs the day you want to leave. And AI capability arrives as a bolt-on feature on the vendor's roadmap, priced as an upgrade, months, or years after it would have actually helped.  

None of that is a reason to build it yourself and inherit the carry instead. It's a reason to ask whether the platform you're renting was ever sized to your business in the first place.

There's a better way there

Framed as build-vs-buy software, both sides look like a trade with no free option. Build, and you fit your business exactly, but you carry the obligation. Buy, and you shed the carry, but the product fits nobody in particular. The way through isn't picking a side. It's a structure that gives you the fit of a build and the accountability of a vendor in one relationship: a partner who builds to your exact workflow, then stays to run it the way a vendor would, priced so keeping the system alive stays cheap rather than becoming a meter that runs forever.  

This is what we've built at thinkbridge with thinkOne, and the results aren't theoretical. We've helped a vertically integrated luxury manufacturer that spent years on packaged ERP still running eighty percent of its business on spreadsheets and email; a custom, cloud-native system spanning design through finance cut its costs sixty percent versus the packaged alternative and reached production in under six months. We replaced 253 spreadsheets and more than a hundred manual processes at a global distribution house with one platform connecting sales, forecasting, and warehousing. Across engagements like these, thinkbridge has delivered more than 350 projects and created over $500 million in measured incremental value, work that compresses transformations traditionally running twelve to eighteen months into under sixteen weeks.  

The commercial model is built the same way the argument demands. The client owns the code, the data, and the roadmap outright from day one, with no license to renew and no migration if the relationship ends.  Cost is spread out like a capital asset over roughly forty to sixty months instead of hitting the P&L as one large build cost or an open-ended subscription. Total cost of ownership typically runs more than sixty percent below comparable SaaS or traditional custom builds over the life of the system.  The platform is built to swap its underlying AI model without touching the client's application, so nobody inherits a single AI lab's pricing changes, roadmap shifts, or acquisition risk. Two people run each engagement: a delivery principal who owns the outcome through every sign-off gate and a customer success lead who owns what comes next, with pricing structured so the partner earns less when the system misbehaves, not more.  

That's the test worth applying to any partner claiming to do this: if they walked away tomorrow, what happens? A real one has already designed its own departure to be survivable. It hands you the code and the context or holds them jointly, rather than hoarding either.

What organizations should actually do

First, run the rightsizing test on your three largest SaaS line items before the next renewal. List what your team actually uses against what you're licensed for. Where the gap is wide, the choice was never build-or-buy; it's whether you keep overpaying for a platform sized for someone else or get the narrow, custom-fit version of what you actually run.  

Second, audit for the tools your own people have already built. Every AI-assisted prototype running inside your business today is either a convenience with a clear owner or a liability quietly accumulating the carry. Find out which.  

Third, stop measuring "build" against your team's spare time and start measuring it against a real delivery model, one that owns the outcome rather than bills the hours.  

The trillion-dollar quarter didn't prove that SaaS is over. It proved the market finally agrees with what the math always said: paying full price for generic software, or quietly building and forgetting to fund the alternative, are both bets against the odds. There's a better way between them, and it was always available. It just took a reckoning this size for the industry to go looking for it.