Diligence

Technical due diligence: what to actually check

A practical checklist for assessing a codebase and engineering team before an acquisition, an investment, or taking over a product, including what has changed now that much of the code was AI-generated.

3 min readBy Mayur Kale

Key takeaways

  • Judge the system by how safely it can be changed, not by how elegant it looks. Deployment frequency and change failure rate tell you more than code style.
  • Bus factor is usually the largest undisclosed risk: how much of this only one person understands.
  • Check dependency and licence hygiene early, it is cheap to check and expensive to inherit.
  • Since a large share of new code is AI-assisted, verify that review and testing scaled with generation. Volume without verification is the modern red flag.
  • Talk to the engineers without their manager present. It is the highest-yield hour of the whole process.

Most technical due diligence produces a document nobody acts on: a list of code-quality observations, a dependency report, and a conclusion that the codebase is "generally reasonable with some technical debt".

That tells you nothing, because every codebase matches that description. The useful question is narrower: what will it cost to do the thing you are buying this in order to do?

Judge changeability, not beauty

Elegant code that nobody can deploy safely is worth less than plain code that ships twice a day. So measure the system's capacity for change:

  • How often do they deploy? Daily is healthy. Monthly means every release is a large, risky batch.
  • How long from merge to production? Hours is good. Weeks indicates a manual gauntlet somewhere.
  • What proportion of releases cause a problem? If nobody can answer, that itself is the finding.
  • How long to recover? Ask about the last outage specifically, not in general.

A team that can answer these four questions with real numbers is a team with control of its system, almost regardless of what the code looks like.

Bus factor is the usual hidden risk

Ask, of each significant subsystem: if this person left tomorrow, what happens?

The answer is frequently uncomfortable, and it rarely appears in a data room. Key-person concentration is the risk most likely to materially change the value of a deal and least likely to be volunteered.

Concrete probes:

  • Who was the last person to touch the payment code? Has anyone else?
  • Can a new engineer set up the project from the README alone? Try it.
  • When someone is on holiday, what waits for them?
  • Is there any documentation written for a reader who was not present?

The checklist

Codebase

  • Tests exist on business-critical paths, and they run in CI
  • CI is green, and has been for more than a week
  • No secrets in version control, current or historical
  • Dependencies within a supportable range; no unmaintained core libraries
  • Licences compatible with your intended use, check transitively

Architecture

  • Someone can draw it on a whiteboard in five minutes
  • Failure modes have been thought about; there is a plan for the database going away
  • The data model matches the business; heavy workaround layers indicate an early wrong turn
  • Scaling constraints are known rather than theoretical

Security and data

  • Authentication and authorisation are centralised, not scattered
  • Personal data is inventoried and its retention is defined
  • Someone owns dependency and security updates
  • Access to production is limited, logged and revocable

Delivery

  • Deploys are automated and reversible
  • There is a staging environment resembling production
  • Monitoring and alerting exist, and someone is on call
  • Incidents produce written follow-ups

Team

  • No subsystem is understood by exactly one person
  • Code review is real, not ceremonial
  • Onboarding takes days rather than months
  • The engineers can explain the product's business model

What AI changed

Two adjustments are now worth making explicitly.

Volume is no longer evidence of capability. A large, recently written codebase used to imply a substantial team working for a long time. It no longer does. Look for whether verification scaled with generation: is there review history, are there tests, can anyone explain the critical paths?

Dependency provenance deserves a real look. A USENIX Security study found code-generating models importing non-existent packages at rates between 5.2% and 21.7% depending on the model, and attackers have responded by registering the invented names. Check that dependencies were vetted rather than accepted, that lockfiles are committed, and that the build would fail rather than silently resolve if a package disappeared.

Talk to the engineers alone

Half an hour with two or three engineers, without their manager in the room, will tell you more than the data room.

Ask what they would fix if given a month. Ask what worries them. Ask what they were told not to mention. Engineers are, as a group, remarkably straightforward about the state of their systems when nobody is performing.

Writing it up

A useful report says three things:

  1. What it would cost to do the intended thing, in engineer-months, with the assumptions stated
  2. What must be fixed before that starts, the short, specific list
  3. What risk remains, key people, unsupported dependencies, unresolved compliance

Not a catalogue of imperfections. Every codebase has those, and listing them obscures the three things that actually matter.

Frequently asked questions

What is technical due diligence?

An assessment of whether a company's software and engineering organisation can support the plan being bought, covering the codebase, architecture, security posture, delivery process, team capability and key-person risk. The question is rarely 'is this code good' and almost always 'what will it cost and how long will it take to do what we intend to do next'.

How long does technical due diligence take?

For an early-stage company, two to five days of a senior engineer's time is usually enough to surface anything material. Larger or regulated targets take one to three weeks. Beyond that you are generally buying reassurance rather than information.

What are the biggest red flags?

No automated tests on business-critical paths; deploys that require a specific person; no staging environment; secrets committed to the repository; dependencies years out of date; a single engineer who understands the core system; and no ability to state a change failure rate. Any one is survivable. Three together usually indicates a rebuild is coming.

How does AI-generated code change due diligence?

It changes what you look for. A large volume of recently written code is no longer evidence of a large, capable team. Check whether review practice and test coverage scaled alongside generation, whether anyone on the team can explain the critical paths, and whether dependencies were vetted, AI-suggested packages sometimes do not exist, which is an established supply-chain attack vector.

Should I use an external firm or my own engineers?

External reviewers are usually better at this, because they have seen many codebases and have no stake in the outcome. Your own engineers are better at judging fit with your systems and roadmap. Doing both, with a short joint debrief, gets you the useful parts of each.

References & further reading

  1. [1]
  2. [2]
  3. [3]

Turn the trend into shipped software

I contract as a senior fullstack and data engineer, building the production systems your customers and your reporting depend on.

Explore services↗