StackLift
All playbooks

Playbook

Technical Due Diligence Checklist

A checklist for judging a software product before you buy, invest or take it over. It covers architecture, code, security, operations, team and ownership, and turns findings into a clear view of risk.

Best reader

Investors, acquirers, founders and CTOs assessing a product or inheriting a codebase

Outcome

A written assessment of risk and remediation work, ready to inform price, terms or a takeover plan.

Use this sequence

1

Set the questions the decision depends on and the access you need.

2

Review architecture, infrastructure and how the system is deployed.

3

Sample the code, tests and dependencies for quality and licensing.

4

Check security, data handling and operational practice.

5

Assess the team, key-person risk and documentation.

6

Write findings by severity with a rough remediation scope.

Scope to the decision

Due diligence answers a deal question, not every technical question. Decide what you need to know to proceed.

Will it scale to the plan?

What will it cost to fix?

Who knows how it works?

Do they own what they sell?

Look beyond the code

Code review is one part. Ownership, operations and people matter as much.

IP and contributor agreements

Open source licenses

Cloud accounts and access

Documentation and runbooks

Check AI-generated code carefully

Prototypes built with AI tools can look finished and lack tests, error handling and security basics. Sample deeper where the code is new.

Test coverage on critical paths

Secrets in the repository

Consistency of structure

Start in 60 seconds

Turn this checklist into a scoped plan.

Answer a few questions and get an AI-assisted, architect-reviewed scope, cost range, and timeline for your software project.

Frequently asked questions

How long does technical due diligence take?

It depends on product size and access. A focused review of a small product is brief; a large platform needs more time. Agree scope and access first.

Who should do it?

Someone independent of the seller with experience in the stack and in running production systems. An outside reviewer can also give a more objective read.

The complete guide

Technical Due Diligence Checklist: the complete guide

Updated November 18, 2026 ยท Published by , Founder, StackLift AI. Written with AI assistance; how we make content.

Short answer

A technical due diligence checklist helps you judge a software product before you buy, invest or take it over. It covers architecture, code quality and technical debt, security, infrastructure, data, the engineering team, documentation, and ownership of intellectual property and open source. The result is a written view of risk and fix effort tied to the deal.

What is technical due diligence?

Technical due diligence is an independent review of a software product and the team behind it, done before a decision such as an acquisition, an investment or taking over a codebase from another team. It answers a practical question: what are we really getting, and what will it cost to make it what we need?

Code review is only part of it. The review also covers how the system runs, who knows how it works, whether the seller owns what they are selling, and how safe the data is. This guide gives general practice and is not legal advice; ownership and contract questions need your lawyers.

What are the steps of a technical due diligence?

  1. Set the questions and access. Output: a short list of decision questions and agreed access to code, environments and people. Involve the deal lead and the reviewer.
  2. Review architecture and infrastructure. Output: a diagram and findings on scalability, hosting and cost. Involve a senior engineer.
  3. Sample the code and delivery. Output: findings on quality, tests, dependencies and the release process. Involve engineers.
  4. Check security and data handling. Output: findings on access, secrets, data protection and incident history. Involve a security reviewer.
  5. Assess the team and knowledge risk. Output: a view of key-person dependence and documentation. Involve the reviewer and deal lead.
  6. Verify ownership. Output: a list of IP, license and contract questions for counsel. Involve legal.
  7. Report. Output: findings by severity, with rough remediation scope and a plan. Involve everyone above.

The sections below give you the checks. For the security part in depth, use the security review checklist.

How do you scope a due diligence to the deal?

A review that tries to check everything delivers little. Start from what the decision depends on, and let those questions set the depth. A buyer planning to double the user base cares about scale; one planning to merge products cares about integration; an investor cares about whether the team can ship.

Deal question to review focus
Deal questionFocus onOutput
Will it scale to our plan?Architecture, load behavior, infrastructure designScaling risks and rough fixes
What will it cost to fix?Code quality, tests, technical debt, outdated platformsRemediation scope by area
Can the team keep building it?Team, documentation, delivery processKey-person and process risks
Is the data safe?Access control, encryption, incidents, privacy handlingSecurity and data findings
Do they own what they sell?IP assignment, open source licenses, third-party termsQuestions for counsel
Can we integrate it?APIs, data model, dependenciesIntegration plan and risks

Agree access rules early: read-only code access, a sample of environments and time with the people who know the system. Ask for a call with the most senior engineer, not just a presentation.

What should you check in architecture and code?

Look for evidence that the system can be understood, changed and run. A clean diagram that matches the code is a good sign. A diagram nobody can produce is a finding. Sample the code in areas that matter most, such as billing, permissions and data handling, rather than reading everything.

Architecture and code checks
AreaCheckRed flag
ArchitectureClear components, boundaries and data flowsOne tangled unit that nobody dares change
Code qualityConsistent structure, readable naming, reasonable sizeLarge copy-pasted blocks and dead code
TestsAutomated tests on critical paths that run in the pipelineFew or no tests, or tests that are routinely skipped
DependenciesCurrent, scanned, licenses knownAbandoned or vulnerable components
Technical debtKnown list with owners and a planUnspoken debt, workarounds on workarounds
DeliveryAutomated build and release, review before merge, rollbackManual releases from one person's laptop
AI-generated codeReviewed, tested, consistentDemo-quality code with no error handling or tests

Look at history as well: commit patterns show who builds the product and whether knowledge is concentrated. See the technical debt glossary entry and the code review entry for background.

What should you check in infrastructure, security and data?

Operations and security are often overlooked in reviews that focus on code. Ask to see the cloud accounts, who has access, how secrets are stored, how backups work, and how incidents have been handled. Then look at the data the product holds, since it may carry obligations that come with the product.

  • Who owns the cloud, domain and third-party accounts, and are they in the company's name?
  • How are secrets stored, rotated and kept out of the repository?
  • Are environments separated, and are backups encrypted and restore-tested?
  • What monitoring, alerting and incident history exists?
  • What personal or sensitive data is held, where, and under which privacy terms and notices?
  • What security reviews, tests or customer questionnaires has the product gone through, and what did they find? Check what any reports actually cover.
  • What are the infrastructure and third-party service costs, and how do they grow with usage?

The production readiness checklist is a good model for what a well-run system has in place.

How do you assess the team and the knowledge risk?

A product is as safe as the people who understand it. Learn who built what, who is still there and who holds knowledge that is written nowhere. Key-person risk is among the most common serious findings in small software companies.

Team and knowledge checks
CheckAskGood sign
Key peopleWho could not be replaced easily?Knowledge shared across several people
DocumentationCan a new engineer set up and ship in a reasonable time?A working setup guide and runbooks
ProcessHow are work, reviews and releases handled?Visible backlog and review habits
ContractorsWho wrote which parts and under what agreement?Written assignment of work
RoadmapWhat is planned and what is blocked?A realistic plan tied to the architecture

Talk to engineers one on one, and ask what they would fix first. The answer often matches your findings.

What ownership, license and contract items should you raise?

Technical reviewers cannot decide legal questions, but they can find the facts. Collect the evidence and pass it to counsel: who wrote the code, whether contributors assigned their rights, which open source licenses are in use and whether any require sharing code, and which third-party services the product depends on.

  • A list of open source components and their licenses.
  • Contributor and contractor agreements, and whether rights to the work were assigned.
  • Terms of key third-party services and any limits on transfer.
  • Data processing terms with customers and subprocessors.
  • Any AI-generated code and the terms of the tools used to produce it.
  • Anything in the repository that should not be there, such as customer data or credentials.

How do you write up findings and plan what comes next?

Write the report for the person making the decision. State the finding, why it matters to the deal, its severity and a rough scope to fix. Separate what must be fixed before closing, what to fix in the first months and what to accept.

Findings format
SeverityMeaningTypical treatment
Deal-affectingChanges price, terms or the decision to proceedResolve or reprice before closing
First-phase fixMust be fixed soon after takeoverPlan and fund immediately
Planned improvementWorth doing, not urgentAdd to the roadmap
AcceptLow impactNote and move on

Many findings lead to modernization or hardening work. See the legacy modernization roadmap and the legacy data audit. StackLift's Production Rescue Sprint audits and hardens AI-coded prototypes; see vibe-coded app rescue. To scope remediation, use the free estimate or contact us.

Questions people ask

How long does technical due diligence take?

It depends on product size and access. A focused review of a small product is brief, while a large platform needs more time. Agree scope, access and a deadline with the seller first.

Who should do the review?

Someone independent of the seller with experience in the stack and in running production systems. An outside reviewer gives a more objective read than the team being assessed.

What are the biggest red flags?

No tests, manual releases, secrets in the repository, one person who holds all the knowledge, unclear ownership of code or accounts, and data handled without clear rules.

Do we need to read all the code?

No. Sample the areas that carry the most risk, such as billing, permissions and data handling, and use tooling for dependency and secret scans. Depth should follow the deal question.

How should AI-generated code be treated?

Review it like any code, with extra attention to tests, error handling, secrets and consistency. It can look complete and still lack the basics that production needs.

Can we use the findings to negotiate?

Yes. Findings with a clear scope to fix inform price, terms and a post-closing plan. Present them factually, with severity and effort, and let counsel handle contract changes.

Sources

Sources and further reading

The standards, rules, research and official documentation this page draws on.