Undisclosed data breaches surfaced during late-stage diligence, after the price had been agreed rather than before.
Source: Verizon / Yahoo, 2017
Institutional-grade software intelligence, from acquisition to exit.

Every software deal is priced on a codebase nobody read
Undisclosed data breaches surfaced during late-stage diligence, after the price had been agreed rather than before.
Source: Verizon / Yahoo, 2017
A platform acquisition where the target's ERP could not integrate. Found after signing, so it could not be negotiated into the price.
Source: RSM case file
Software transactions are re-traded on 30–40% of deals, once the buyer surfaces code, security or licensing exposure during diligence.
Source: PitchBook aggregate data
The target initiates the assessment, authorises the environment directly, and receives a signed record of everything that happened inside it. Our inability to reach the source is enforced by the architecture, not asserted by policy.
The analysis engine is built, signed and locked to one verified version before anything starts. It runs on hardware that keeps its memory encrypted while the work happens, closed to the operators of the machine it runs on as much as to us. The target confirms the environment is running that approved version before releasing anything to it.
The target authorises the environment directly. The key covers only the repositories it selects, and its private half is created inside the environment and can never be copied out, so it is cryptographically bound to that single run and worthless anywhere else. Exira is never a party to it. It lapses when the checkout finishes, and the target can withdraw it sooner.
The repository is pulled over an encrypted connection straight from the target's own provider into storage that exists only for that run. Nothing routes through Exira. Analysis happens where the code already sits: inside the environment it is processed as data rather than run, and nothing the repository asserts can change how that analysis behaves.
Findings leave as a structured register, validated against a published schema. Evidence travels as file paths, line ranges and content hashes, so the report points at code without ever containing any. The environment and its keys are then destroyed, and the target receives a signed, tamper-evident audit record: what was authorised, what ran, what left, and when it was torn down.
Each module reads one part of the codebase. The findings that move a price usually sit where two of them meet, so every assessment cross-checks them before it reports.
We find the systems that depend on a handful of engineers, including people who have already left the company.
We measure dependency exposure and how quickly patches land, then check how secrets are handled and which controls the pipeline enforces.
We map the services and how data moves between them, then assess how the design would cope with ten times the load.
We judge delivery pace and engineering discipline from the repository history, which shows how the team really reviews and tests its work.
We separate obligations enforced in code from those that exist only in policy documents, and flag what must be verified outside the codebase.
We check every dependency licence against how the product is distributed, and identify what carries through the transaction.
We compare runtime, framework and platform versions with their end-of-support dates and list the upgrades that are already overdue.
We judge whether AI is central to the product or added on later, looking at provider dependence, evaluation practice and the underlying data.
We map the interfaces the product exposes and relies on, and estimate the true cost of integrating it with an acquirer's systems.
We trace infrastructure spend back to the design decisions behind it and check whether cost controls exist in the code.
We quantify the deferred work in the codebase and convert it into the engineering months needed to clear it.
Our models are fine-tuned on completed assessments and the deal outcomes that followed. An independent critic reviews every conclusion before it reaches you.
Each finding is given a disposition and a remediation estimate in engineering months, and points to the evidence behind it.
Material risk across two modules
The event streaming backbone, the caching and job-queue layer and the identity data-access layer are all mid-migration at the same time. Each migration is justified and well run, with dual-write patterns keeping old and new systems in sync. The concern is that all three are open together. That adds operational complexity and leaves room for data inconsistency until each one is closed out.
At this cost and turnaround, technical diligence stops being something you commission once and becomes a screen, then a monitor, then a defence.
Run it on targets you would never resource a full engagement for. Firms doing this aren't just faster; they see more of the market.
Architecture, security, licensing and remediation cost in engineering months, while there is still a number to move.
Scheduled re-runs track debt accumulation, security drift and technical covenant signals months before they reach revenue.
The same assessment, read from the other side: what a buyer's diligence would surface, while remediation is still a sprint.