Skip to main content
The Lacanians
Startup8 min read

Technical Due Diligence for an AI-Built Startup

A practical checklist for investors, acquirers, and founders preparing a raise when AI coding agents wrote much of the product: what to check, what is a red flag, and what a two-week review should produce.

A

Abdul Hamid Achik

Demos Hide What Diligence Needs to See

A product built largely with AI coding agents demos well. The screens render, the flows complete, and the founder can ship a feature in an afternoon. None of that shows whether the system survives a second engineer, a security questionnaire, or a customer who asks for their data back.

Technical due diligence exists to answer that. If you are an investor or acquirer, it tells you what you are buying. If you are a founder preparing a raise, it tells you what a reviewer will find before they find it. The checklist below is ours. It is built from checkable items, not impressions.

How to Run the Check

Every item below should end in evidence you can look at: a file, a query result, a command output. “The founder says it is handled” is a lead, not a finding.

Ask for read access to the repository, the deploy platform, a read-only database connection, and the vendor consoles. If a reviewer cannot get that in a day or two, record it as the first finding.

The Checklist

1. Tenant Isolation and Authorization

If the product serves more than one customer, find out where separation is enforced. Application code that filters by account ID is a convention. A database policy or a server-side authorization layer that rejects the request is a guarantee.

Check that every route accepting an object ID verifies the caller may touch that object, on the server. Create two test accounts and try to read one account’s records with the other’s session. Hidden UI buttons prove nothing.

Agents tend to write the filter into the query they were asked about and miss the neighboring endpoint. We covered the database side in Multi-Tenant Postgres Done Right: the policy is the authority, and the application query is one of several things that must agree with it.

2. Reproducible Migrations

Apply the migration history to an empty database and compare the result with the live schema. If they differ, someone changed production by hand.

Check that migrations are checked into the repository, ordered, and applied by the deploy process rather than by a person pasting SQL.

3. Secrets Handling

Search the repository and its git history for keys, tokens, and connection strings. Then check how the running system receives them: a secrets manager or platform environment variables is the baseline.

Ask who can read production secrets today, and whether keys were rotated after the last contractor or agent session. Agent transcripts and pasted logs are a common leak path.

4. Tests That Exercise User-Visible Behavior

Count is the wrong metric. Open the tests and ask what they would catch. A suite that mocks the database, the auth layer, and the payment client mostly proves the mocks work.

Look for end-to-end checks on the paths that earn money: sign-up, login, the core action, billing. We argued in Looks Correct Is Not Is Correct that running the thing beats reading the thing, and the same holds for a test suite. For how to make an agent’s “done” carry evidence, see Done Is Not Verified.

5. Dependency and License Risk

List direct dependencies and read the lockfile. Check for packages that are abandoned, archived, or maintained by one person, and for install-time scripts you did not expect.

Agents sometimes add a package for a ten-line problem, or pull in a license that conflicts with a commercial product. Run a license report and have someone read the copyleft entries. Confirm the lockfile is committed and the build uses it.

6. Reproducible Deploys and Rollback

Ask someone who did not build the system to deploy it from a clean checkout, then roll back to the previous version. If either step needs the founder’s laptop, a manual console click sequence, or tribal knowledge, write it down as a finding.

Confirm that staging exists and that production configuration is separate from it.

7. Observability

Find out what tells you when the product breaks at 2 a.m. Look for error tracking, structured logs you can search, and an alert that reaches a human. Then check that logs do not contain passwords, tokens, or personal data.

Ask for the last real incident and how it was diagnosed.

8. Model and API Cost Ownership, and Vendor Lock-In

If the product calls an LLM or other metered API, find out whose account pays, whether per-customer usage is measured, and what stops one customer or one bug from running up the bill. Rate limits, spend caps, and usage logs are the evidence.

Then map lock-in. Note which vendors hold the data, the auth, the payments, and the model calls, and whether a swap is a day of work or a rewrite. Prompts and model choices should live in configuration, not scattered through the code.

9. Data Export and Deletion

A customer will eventually ask for their data, or ask you to delete it. Try both. If export means an engineer writing a one-off script, and deletion leaves copies in logs, backups, and third-party tools, you have a compliance and trust problem.

Check backups, and ask when anyone last restored one.

10. Bus Factor and Documentation

Find out how many people can deploy, debug, and extend the system. If the answer is one founder plus an agent, that is the risk. Look for a README that gets a new engineer running, a short architecture note, and recorded decisions about the choices that are hard to reverse.

A repository of agent-generated files with no map of how they fit together is a bus-factor problem even when the code is fine.

Red Flags Versus Acceptable Debt

Not every rough edge matters at every stage. The useful split is whether a problem can hurt customers or block the business before the next milestone.

Red flags are findings that threaten customers, revenue, or the deal:

  • Tenant data separated only by client-side filtering.
  • Secrets in the repository history, or shared by everyone.
  • No way to deploy or roll back without the original author.
  • Production schema that cannot be rebuilt from migrations.
  • No tests on the paths that earn money, with a mocked suite hiding the gap.
  • Unmetered model or API spend with no cap.
  • No tested path to export or delete a customer’s data.

Acceptable debt is cost you can schedule:

  • Inconsistent naming and duplicated helpers.
  • Thin documentation that one engineer can fix in a week.
  • A framework version one major release behind with no known exploit.
  • A monolith that load does not yet force you to split.
  • Partial test coverage outside the core paths.

The test for any item is who takes the hit if it goes wrong: a customer or the deal, or an engineer who loses an afternoon. This is the distinction behind the true cost of a vibe-coded MVP, where the expense is rarely the messy code and usually the unowned risk.

What a Two-Week Review Should Produce

Two weeks is enough for an experienced reviewer to work through the checklist above. A review that ends in “looks mostly fine” has not done its job, so the output should be specific.

  1. Risk-ranked findings. Each finding states what was checked, what was found, the evidence, and the consequence. Rank by customer and deal impact, not by how ugly the code looks.
  2. Remediation estimate ranges, framed qualitatively. Group each fix as days, weeks, or a structural rework, with the assumptions behind it. A range with stated assumptions is honest. A single number invented in week one is not.
  3. A split of must-fix versus schedule-later. Red flags that must be closed before a raise or close, and debt that can sit on the roadmap.
  4. A one-page summary for non-engineers, so a board can act without reading a repository.
  5. A list of open questions. Anything the reviewer could not verify, because access was missing or no one could answer.

Where to Go From Here

If you are a founder, run the checklist on yourself before the data room opens. Fix the red flags first, write down the acceptable debt so it reads as a decision, and keep the evidence in one folder.

If a review turns up more than your team can close, a rescue engagement or ongoing fractional technical leadership can help. We covered when the second option fits in Why Your Startup Needs a Fractional CTO in the AI Era.

A

Abdul Hamid Achik

Founder and lead engineer at The Lacanians. Abdul builds production software, developer tools, and local-first systems from Guadalajara for teams worldwide.