What Did We Actually Buy?

Why acquisition debt lives in the codebase and how to find it before it finds you

Ownership and understanding arrive separately. You can hold the title to something you cannot navigate. In most disciplines that gap closes quickly. A building comes with drawings. A machine comes with a manual. Software rarely comes with either and the people who could have explained it are usually gone by the time the questions start.

The MGA sector has been consolidating at pace. The largest players have been absorbing brokers, distribution businesses and underwriting operations in succession, building scale through acquisition rather than organic growth alone. Each deal adds customers, products and market position. Each deal also adds a technology estate.

Those estates were not built to be handed over. They were built to function. Policy administration systems layered over years. Integrations written by contractors who have long since moved on. Bespoke logic embedded in codebases that predate the current leadership team by a decade. The acquiring business takes on the liability the moment the deal closes. The knowledge of what is actually in those systems rarely transfers with it.

Due diligence has mature frameworks for financials, legal and commercial risk. The technical estate gets a fraction of the same scrutiny. A few days, a senior engineer, a list of known issues the seller volunteers. The things that do not surface in that conversation are exactly the things that surface later, at cost.

The post-close integration plan assumes a level of technical clarity that almost never exists. The change scoped for six weeks takes six months because nobody knew what it would touch. The incident cascades through three systems because nobody knew what depended on what. The remediation budget was never in the deal model because nobody ran the analysis before signing.

The understanding of what is in an acquired codebase walked out with the developers who built it, or with the outsourced supplier who delivered it and moved on to the next engagement. What remains is a system the new owners navigate by inference, by the parts they can see and the assumptions they make about the parts they cannot.

Decoder runs the analysis the due diligence process never delivered. Import the codebase before or after close and get a complete picture of what is in it: architecture, dependencies, technical debt hotspots, health scores across maintainability, scalability and testability. The financial cost of remediation comes back in language that maps directly to the deal model. A survey of the estate, not a conversation about it.

Acquisition debt accumulates in the gap between what was represented in the deal and what the codebase actually contains. Every broker absorbed into a growing estate adds more inherited code, more unknown liability, more decisions that will eventually need to be made about systems nobody currently understands.

The survey was always possible. For most deals it just was not run. It can be.