M&A software diligence: the contracts are the liabilities.

Financial diligence in an acquisition is exhaustive: the revenue is scrubbed, the debt is mapped, the working capital is modeled to the dollar. The target's software estate, by contrast, is often handled with a spreadsheet of vendor names and annual spend, treated as a run-rate cost to be folded into the model rather than a set of contracts to be read. This is a mistake with real money in it, because a software estate is not just a line of ongoing cost. It is a stack of agreements, and agreements contain both the liabilities that will survive the deal and the synergies that help justify it, neither of which shows up in a spend total.

The liabilities are the sleeper risk. Software contracts commonly contain change-of-control provisions that trigger the moment ownership changes, letting a vendor reprice, demand consent, or even terminate, and an estate full of auto-renewals and uncapped uplifts carries forward obligations the acquirer inherits whole. The synergies are the flip side: overlapping tools between acquirer and target that consolidate, volume that should command better rates, contracts that can be renegotiated from a stronger combined position. Both live in the contracts, and both are invisible until someone actually reads them, which on a deal timeline almost nobody does.

The liabilities that trigger on close

The most dangerous clause in an M&A software context is change-of-control, and it is common enough that it should be assumed present until confirmed absent. Many enterprise agreements give the vendor rights that activate specifically when the customer is acquired: the right to consent to the assignment of the contract, the right to reprice now that the customer is part of a larger, richer parent, sometimes the right to terminate. An acquirer who closes without knowing which of the target's contracts carry these provisions can find, the day after close, that a critical system's vendor is entitled to renegotiate from a position the deal itself created.

Beyond change-of-control sit the ordinary liabilities that simply carry forward: auto-renewals that will fire on their own schedule regardless of the transaction, uplift clauses with no cap that compound into the combined entity's spend, and termination terms that constrain the integration you are planning. None of these are visible in a spend summary, and all of them become the acquirer's the moment the deal closes. Reading the target's contracts for these provisions is not optional diligence, it is the difference between knowing what you are buying and discovering it afterward, when the leverage to do anything about it is gone.

The synergies that justify the multiple

On the other side of the ledger, the software estate is where a meaningful slice of deal synergy actually lives, and it is more defensible than most synergy claims because it rests on contracts you can read rather than revenue you have to project. The clearest source is overlap: where the acquirer and the target both run tools that do the same job, consolidating onto one is a real, bankable saving, and the combined volume often commands a better rate than either entity got alone. A diligence that maps the two estates against each other turns "there should be some IT synergies" into a specific list of overlapping vendors and a priced consolidation opportunity.

The discipline that makes these numbers credible is conservatism. A synergy memo is read by people whose job is to find the hole in it, so a software synergy case survives scrutiny only if it underwrites what it can defend and flags what it cannot, pricing consolidation from real overlap and benchmark data rather than optimistic assumption, and admitting where a vendor cannot be assessed instead of filling the gap with a number. A conservative, contract-grounded software synergy figure is worth more in the deal model than an inflated one, because the inflated one gets caught in confirmatory diligence and the conservative one holds.

Reading a whole estate on a deal clock

The reason software diligence gets skimmed is time. A target may have hundreds of contracts, a deal runs on a compressed timeline, and reading every agreement for change-of-control clauses, renewal traps, and consolidation candidates is a task that, done by hand, does not fit the window. So it does not get done, and the estate is folded into the model as a spend line with the risk and the opportunity both unexamined. The way to actually do it is to make reading the whole stack fast: load the target's contracts into a contained space and query them at once, so a question like "which of these carry change-of-control provisions?" becomes a column across the estate rather than a week of manual review.

Speed is what makes the diligence real rather than aspirational. When the whole estate can be read in the time the deal allows, the liabilities surface as a risk register before close, the overlaps surface as a priced synergy list, and both feed the model with grounded numbers instead of placeholders. And because diligence data is sensitive and time-bound, the right way to do it is in an isolated space that is destroyed on a retention clock when the work is done, so the target's confidential contracts do not linger after the deal closes or falls through. Fast, contained, and self-erasing is exactly the shape M&A software diligence needs.

What deal diligence must surface

Diligence informs the deal, it does not price it

Software diligence surfaces the liabilities and underwrites the synergies it can defend; it does not value the company or replace the confirmatory work a transaction demands. Its output is a grounded, conservative read of one slice of the target, the software estate, produced fast enough to matter while the deal is live, and the judgments about how the findings weigh against the whole deal belong to the deal team and their advisers.

What reading the estate removes is the blind spot. A deal that treats the target's software as a spend line inherits every clause in it unexamined, and the change-of-control provision or the uncapped uplift becomes the acquirer's surprise after close, when nothing can be done about it. Reading the contracts, fast and conservatively, turns the software estate from a folded-in assumption into what it actually is, a set of concrete liabilities to price and a set of concrete synergies to bank, which is exactly what diligence is supposed to produce.