Technical due diligence before you raise
Investors will look under the hood before they wire money. What they check, the extra questions for AI-built products, and how to have the evidence ready in 30 days.
Updated October 24, 2026: Re-checked every source on October 24, 2026; no facts changed.

Technical due diligence before you raise is an investor's check that your product is real, that your company owns it, and that it can grow without a rewrite. As of October 24, 2026, the way to pass it is to show evidence, not intentions.
Show who owns the code and accounts, how the system is built and secured, what the tests prove, how often you release, and what happened when things broke. If an AI tool wrote much of your code, expect extra questions. Investors will ask who owns that code, and whether anyone on your team can explain and change it safely.
What will an investor's engineer ask about a product built partly or mostly with Lovable, Bolt, v0, Replit, Cursor or a similar tool, before a seed or Series A round? Legal and standards facts below come from the primary sources listed at the end, checked on October 24, 2026. It is not legal advice: ask your lawyer about anything that touches ownership.
What do investors check in technical due diligence?
They check ownership, architecture, security, code quality, delivery and the team. The depth depends on the round and the investor. An angel may ask a few questions on a call. A larger fund may send a written questionnaire, or hire an outside engineer to review the code. The topics are usually the same; only the depth changes:
| Area | What they ask | Evidence that answers it |
|---|---|---|
| Ownership | Does the company own the code, data, domains and accounts? | Repository in a company organization, accounts in the company's name, contributor agreements |
| Architecture | Can it handle ten times the users without a rewrite? | A one-page system map and the known limits |
| Security | Who can read which data, and how do you know? | Access rules, a recent security review, a list of secrets and who holds them |
| Quality | Can the team change it without breaking it? | Tests that run on every change, and their results |
| Delivery | How often do you release, and how often does a release fail? | Release history, rollback record, incident notes |
| Team | Who understands this system if one person leaves? | Named owners per area, written runbooks |
None of these areas needs a perfect answer. Investors know early products carry technical debt. What they look for is that you know where it is, and that you have a plan that fits the money you are raising. If you are unsure whether to refactor or rebuild before you raise, score the app first.
How do you prove the company owns its code and accounts?
Put the repository in a company-owned GitHub organization, get a signed assignment from everyone who wrote code, register every account to the company, and list your open-source packages and their licenses. Ownership problems can delay a close, because fixing them needs other people's signatures. Start here, weeks before the data room opens.
- Code: the repository lives in a GitHub organization the company owns, with at least two company admins. Not in a founder's or freelancer's personal account.
- People: everyone who wrote code, including freelancers and agencies, has signed an agreement that assigns their work to the company. If any are missing, a lawyer should draft the fix. Our guide to choosing a tech partner explains why the written assignment matters.
- Accounts: hosting, database, domain, email sending, payments, analytics, app stores and AI providers are registered to the company, billed to the company, and listed in one document.
- Licenses: you can list the open-source packages you depend on and their licenses. GitHub's dependency graph shows each package's version and license, and can export a software bill of materials (SBOM) for audit or compliance purposes.
If a developer or builder still holds an account, move it now. Our guide to handing over an AI-built app to developers lists the accounts to move and the order to move them in.
What changes when AI wrote much of the code?
Two questions get sharper: who owns the output, and does anyone understand it. Expect an investor's lawyer to ask how much of the code your team shaped, reviewed and changed, and a diligence engineer to look for data readable by the wrong users, keys in the browser and packages nobody chose.
On the first, read your tools' terms. Lovable's terms, last updated August 28, 2026, say you own the AI output generated for you, subject to any third-party rights. Copyright is a separate question. In Part 2 of its report on copyright and AI, published January 29, 2025, the US Copyright Office concluded that AI output can be protected only where a human author has determined enough of its expressive elements. Creative arrangements or changes a person makes to the output can count. The mere provision of prompts does not. So an investor's lawyer may ask how much of the code your team shaped, reviewed and changed. A clean commit history with reviewed pull requests is the best evidence you can have.
On the second, generated code tends to work on the screens and fail underneath: data readable by the wrong users, keys in the browser, packages nobody chose. Our article on vibe coding security risks lists the common ones and how to check each. Expect a diligence engineer to look for the same things.
Be ready to answer these directly:
- Which tools generated the code, and which parts were written or rewritten by people?
- Is every change reviewed by an engineer before it reaches production?
- Can someone on the team explain the data model and the access rules without opening the AI tool?
- If the AI builder disappeared tomorrow, could you still build, run and release the app? This is the vendor lock-in question.
What architecture and security evidence should you prepare?
You need a one-page system map, the known limits, your data access rules with the test that proves them, a secrets inventory, a recent security review against a named standard, and a plain statement of your compliance status. Use this as your technical due diligence checklist. A short, true document beats a long, aspirational one. Prepare:
- 01A system mapOne page: the front end, the server, the database, file storage, scheduled jobs, and every outside service, with where each one runs.
- 02Known limitsWhat breaks first as usage grows, and roughly when. Naming the bottleneck is more credible than saying there is none.
- 03Data access rulesWho can read and change each kind of data, and the test that proves a user cannot read another user's rows.
- 04A secrets inventoryEvery key by name and purpose, where it is stored and who can see it. Never the values.
- 05A security reviewThe results of a recent review against a named standard, and what you fixed. OWASP's Application Security Verification Standard, at version 5.0.0, is an open standard built as a basis for testing web application security controls.
- 06Compliance statusSay plainly what you have and what you do not. A SOC 2 report covers an examination of a service organization's controls relevant to security, availability, processing integrity, confidentiality or privacy. If you have not started one, say when customers will need it.
A code audit by someone outside the team, done before the round, turns most of this into a report you can hand over. A penetration test is worth doing first if you handle payments or sensitive personal data. If enterprise buyers are in your plan, read up on SOC 2 early and plan the time it needs. If the product is built in Lovable, this is the same evidence a production-ready Lovable app needs anyway.
What do tests, releases and incident records need to show?
That the team can change the product safely and often: tests that run on every change, how often releases reach production and get rolled back, a rehearsed rollback, and a short note for each outage. Claims like "well tested" mean little; numbers from your own CI mean a lot.
- Tests: how many, what they cover, and that they run on every change. Show the CI history, not a screenshot of one green run.
- Releases: how often changes reach production and how often one has to be rolled back. DORA, a program run by Google Cloud, names five delivery metrics: change lead time, deployment frequency, change fail rate, failed deployment recovery time and deployment rework rate.
- Rollback: proof you can undo a bad release. A rehearsed rollback is worth more than a promise.
- Incidents: a short note for each outage or data problem: what happened, how long it lasted, what changed afterwards.
How should you prepare in the 30 days before you raise?
Spend the first days moving the repository and every account into the company's name, then write the system map and secrets inventory, make the tests run on every change and stop users reading each other's data, export the release and incident record, and finish with a technical folder in the data room and a rehearsed call.
- 01Days 1 to 5: ownershipMove the repository and every account into the company's name. List contributors and check each has signed an assignment. Ask your lawyer about any gaps.
- 02Days 6 to 10: the mapWrite the one-page system map, the secrets inventory and the list of outside services with what each costs a month.
- 03Days 11 to 20: the checksMake the tests run on every change. Fix anything that lets one user read another's data. Rotate any key that was ever shared in chat or email. Commission an outside review if you can.
- 04Days 21 to 25: the recordExport the release history and CI results. Write short notes for past incidents. Write down the known limits and the technical debt, with a plan for each.
- 05Days 26 to 30: the roomPut it all in a technical folder in the data room, and rehearse the call: one person who can answer every question above without guessing.
Thirty days can be enough for a small product with clean ownership. If accounts sit with former contractors, or nothing is tested, start earlier.
What should be on your technical due diligence checklist?
It should cover ownership and accounts, AI-written code, architecture and security, tests, releases and incidents, and the team and data room. Here is everything above as one checklist to copy into a document and adapt to your product. Tick what is true today, and put the rest into your 30-day plan.
Ownership and accounts:
- The repository is in a GitHub organization the company owns, with at least two company admins.
- Everyone who wrote code, including freelancers and agencies, has signed an agreement assigning their work to the company.
- Hosting, database, domain, email sending, payments, analytics, app stores and AI providers are registered to the company and billed to it.
- Every account is listed in one document, with who owns it.
- You can list every open-source package you depend on, with its license.
AI-written code:
- You can say which tools generated the code and which parts people wrote or rewrote.
- Every change is reviewed by an engineer before it reaches production.
- The commit history shows reviewed pull requests.
- Someone on the team can explain the data model and the access rules without opening the AI tool.
- You could build, run and release the app if the AI builder disappeared tomorrow.
Architecture and security:
- A one-page system map shows the front end, server, database, file storage, scheduled jobs and every outside service, and where each runs.
- The known limits are written down: what breaks first as usage grows, and roughly when.
- The access rules say who can read and change each kind of data.
- A test proves a user cannot read another user's rows.
- A secrets inventory lists every key by name and purpose, where it is stored and who can see it, never the values.
- No secret is in the repository or in the browser code.
- Every key ever shared in chat or email has been rotated.
- A recent security review against a named standard, such as OWASP's Application Security Verification Standard, is on file with what you fixed.
- If you handle payments or sensitive personal data, a penetration test has been done.
- Your compliance status is written down plainly, including when customers will need SOC 2.
Tests, releases and incidents:
- Tests run automatically on every change, and the CI history shows it, not one green run.
- You can say how many tests there are and what they cover.
- The release history shows how often changes reach production and how often one has to be rolled back.
- A rollback has been rehearsed, not just promised.
- Every outage or data problem has a short note: what happened, how long it lasted, what changed afterwards.
Team and the data room:
- Each area of the system has a named owner and a written runbook.
- The technical debt is written down, with a plan for each item that fits the money you are raising.
- All of this sits in a technical folder in the data room.
- One person can answer every question above on the call without guessing.
What are the red flags that slow a round down?
The red flags are code or key accounts held by someone who no longer works with you, nobody who can explain who sees what, secrets in the repository or browser code, tests that do not run automatically, no rollback or outage record, and a rewrite plan with no cost estimate.
- The code or a key account belongs to someone who no longer works with you.
- No one on the team can explain how the app decides who sees what.
- Secrets in the repository or in the browser code.
- No tests, or tests that do not run automatically.
- No way to roll back a release, and no record of past outages.
- A plan to rewrite everything after the round, with no estimate of what it costs.
Most of these can be fixed in weeks. Found by the investor's engineer instead of by you, each one costs trust you will want back during negotiations. If the app is built in Lovable and you need engineers to fix what investors find, start before the data room opens.
The Starter plan is $2,999 a month paid annually, $3,999 a month billed quarterly, or $4,999 month to month; Growth is custom-priced. See pricing. To find your gaps first, take the free production-readiness check: 22–35 questions, a score out of 100 and your three biggest risks. If your diligence prep has already found gaps in an app that is live, our vibe-coding rescue service starts with an architecture review of what exists, then fixes what is risky, such as access rules, secrets and payments.
Sources
Each legal, standards or platform fact above comes from one of these pages, checked on October 24, 2026. We review this page every 30 days.
- US Copyright Office: Copyright and Artificial Intelligence, Part 2: Copyrightability, published January 29, 2025 (copyright.gov/ai).
- Library of Congress, Copyright Office blog: Inside the Copyright Office's report, Part 2: Copyrightability, February 2025 (blogs.loc.gov/copyright).
- Lovable: Terms of Service, Ownership section, last updated August 28, 2026 (lovable.dev/terms).
- OWASP: Application Security Verification Standard project page, current version 5.0.0 (owasp.org).
- AICPA & CIMA: SOC 2, Reporting on an Examination of Controls at a Service Organization (aicpa-cima.com).
- DORA: DORA's software delivery performance metrics guide (dora.dev/guides/dora-metrics).
- GitHub documentation: About the dependency graph, including SBOM export (docs.github.com/en/code-security/supply-chain-security/understanding-your-software-supply-chain/about-the-dependency-graph).
- Case-study facts: our Looph, Bell and Inkwave case studies, as published on this site (plutonapps.com/work/looph; plutonapps.com/work/bell; plutonapps.com/work/inkwave); Starter and Growth prices from our pricing page (plutonapps.com/pricing).
Common questions
When does technical due diligence happen in a fundraise?
Often after a term sheet or a strong first meeting, and before the round closes. Early investors may only ask a few questions on a call. Larger funds may have an engineer review the code. Prepare before you start pitching, because fixing ownership takes time.
Is an AI-built app a problem for investors?
Not by itself. Investors care whether the company owns the code, whether it is secure, and whether the team can change it safely. Show reviewed changes, tests that run on every change and clear access rules. Then the tool that wrote the first draft matters much less.
Do I need SOC 2 before a seed round?
It depends on your customers. Investors want to know whether your customers will require it, and when. Say plainly what you have today and when you plan to start, and show the security basics in the meantime.
Who owns code generated by an AI app builder?
Check each tool's terms first. Lovable's terms say you own the output, subject to third-party rights. Copyright is a separate question: the US Copyright Office has said the mere provision of prompts is not enough for protection. Ask your lawyer how this applies to your company.
What should go in the technical folder of a data room?
A one-page system map, the list of accounts and who owns them, contributor agreements, a secrets inventory without the values, security review results, test and release history, incident notes, and a short note on known limits and technical debt.
More on this: Product strategy & scoping · How to hire a Lovable developer or Lovable expert (and what it costs)
Built something in Lovable you want people to rely on?
We are the engineers who take it the rest of the way — secured, tested, released and supported.


