Guide
What does a software audit include? Scope, report, and timeline
A software audit reviews code, architecture, infrastructure, and workflow, with security, data, and delivery checked across all four. Here is what each area covers, what the report should contain, how to prepare, and how long it takes.
- Published
- Updated
- 10 min read
- By Dev Talan
Key takeaways
The short version. Each point is explained in full below.
- 01
Each finding gets two scores, the harm it could do and the work the fix takes, which place it in one of four groups: fix now, fix next, plan, or accept.
- 02
Before the audit, check whether any
.envfile with real keys was ever committed and rotate those keys, and on Supabase, list the tables with row-level security switched off. - 03
Grant read-only roles on the repository with its full git history, hosting, CI, and error tracking. The reviewer never needs write access, production credentials, or copies of customer data.
- 04
If the report has to land before a fundraise or a board meeting, agree the start date when you agree the scope, and set up access before that date.
- 05
After the walkthrough, start the fix-now group straight away, and add a test, a CI check, or a database policy for each fix-now finding so a later change can't undo it.
A software audit includes an outside review of a product's code, architecture, infrastructure, and workflow, with security, data, and delivery checked across all four. It ends in a written report that ranks the risks, says what to fix first, and sets out a build path with rough costs. A focused audit of one product takes about 3 to 5 days of review.
What does a software audit include?
#The audit a startup commissions before a fundraise, a rebuild, or a new CTO's first month covers those four areas, and security, data, and delivery questions run through all of them, so the table gives each its own row. It's a different job from a license audit, which counts software seats, or a penetration test, which attacks the running app. The table shows the question each area answers and the evidence a reviewer reads to answer it.
| Area | The question it answers | Evidence the reviewer reads |
|---|---|---|
| Code | Can another engineer change this safely? | Structure, duplication, error handling, tests, and dependency health |
| Architecture | Will the design hold at the next stage of growth? | Data model, service boundaries, background jobs, integrations, and caching |
| Infrastructure | Does it run, recover, and stay affordable? | Hosting, environments, backups, monitoring, error tracking, logs, and running costs |
| Security | Who can see or change what they shouldn't? | Sign-in, authorization on every route, tenant isolation, secrets, and input handling, mapped to the OWASP Top 10:2025 |
| Data | Is customer data correct, recoverable, and in the right place? | Schema, migrations, indexes, where personal data lives, retention, and backup restores |
| Workflow | How does a change get written, reviewed, and merged? | Pull requests, code review, CI checks, branch protection, and written decisions |
| Delivery | How does a change reach users, and how is it undone? | Deploy process, preview environments, feature flags, rollbacks, and incident history |
Where the review spends most of its time
#An audit can't read every line of a large codebase in a few days, and it shouldn't try. A good reviewer reads the risky paths closely and samples the rest: sign-in, permissions, payments, file uploads, anything that touches customer data, and the jobs that run without anyone watching. Dependency and secret scanners cover breadth. A person covers judgment, such as whether the access rules match how the business works.
If the product has AI features, the review adds the prompts, the retrieval setup, what the model is allowed to do, and whether evals catch regressions. Our RAG architecture guide shows what a sound retrieval setup looks like. Building the first version with AI coding tools is a sensible speed trade, and those products get the same review as any other, with extra attention on what generated code commonly misses: authorization checks, failure paths, and consistency between similar features. Our guide to AI-generated code risks covers those gaps in detail.
A code audit checklist
#Use this list to judge any audit proposal, ours included. A complete review answers each item with evidence.
- A new engineer can run the product locally by following the README, with no setup steps that live only in someone's head.
- Every API route checks who the user is and what they may access, on the server and not only in the UI.
- One customer can't read another customer's data, enforced in queries or database policies.
- No secrets sit in the repository or anywhere in its git history.
- Dependencies are current enough to patch, and known vulnerable versions are listed.
- Payments, webhooks, emails, and other external calls have failure paths.
- Tests cover the paths where a bug would cost money or data.
- Slow queries, missing indexes, and list pages that run one query per row are identified.
- Backups exist, and someone has restored one.
- Every change goes through review and CI before it reaches production.
- A bad release can be rolled back quickly, and more than one person knows how.
- Errors in production alert a person instead of sitting in a log file.
What an audit leaves out
#A software audit doesn't include a penetration test, SOC 2 or ISO 27001 readiness work, or a legal review of IP and open source licenses. It finds security problems in the code and configuration, but it can't prove a product is secure. If customers or investors need a pen test, the report should say so and list what to fix before you book one.
What does a technical audit report look like?
#A technical audit report has four parts: a summary for non-engineers, ranked findings, an order of work, and a build path with rough costs, followed by a walkthrough call. Length isn't the measure of quality. A report padded with raw scanner output is harder to use than a short list of findings that each carry evidence and a fix.
- Summary for non-engineers
- A page or two that a founder, board member, or investor can read on its own: the overall state, the few risks that matter most, and the recommended next step.
- Ranked findings
- Each finding names the file, setting, or process involved, explains the risk in plain terms, shows the evidence, gives the fix, and sizes the work.
- What to fix first
- The findings put in an order of work, so the team knows what to start this week and what can wait a quarter.
- Build path with rough costs
- The sequence of work from where the product is to where it needs to be, with a rough cost for each step, whoever ends up doing it.
- Walkthrough call
- A session where the reviewer takes your team through the report, answers questions, and helps you choose the next step.
How findings are ranked
#Every finding gets two scores: the harm it could do, and the work the fix takes. Together they put it in one of four groups.
| Group | What it means | Example |
|---|---|---|
| Fix now | Could expose data, lose data, or take the product down | An API route returns any customer's records to any signed-in user |
| Fix next | Slows every change, or will break at the next growth step | A list page runs one query per row and times out once a customer has a few thousand records |
| Plan | Real debt, best paid down when the team next works in that area | Pricing logic copied into four screens with small differences |
| Accept | Known, written down, and not worth fixing at this stage | One hosting region with no failover, for a product with no uptime commitment yet |
What one finding looks like
An illustrative example, not from a client. The payment webhook accepts unsigned events. The endpoint that marks invoices as paid never verifies the payment provider's signature, so anyone who finds the URL can post a fake payment. Evidence: the handler parses the request body without reading the signature header. Fix: verify the signature against the raw request body with the provider's official library, reject anything that fails, and add a test that sends a forged event. Size: small. Group: fix now.
How should you prepare for a code audit?
#Preparing for a code audit usually takes an afternoon: grant read-only access, gather the documentation that exists, and name the people. Missing documents shouldn't delay the start, because a missing document is a finding too.
- 01Name the decisionWrite one sentence on what the report should help you decide: raising, rebuilding, hiring, or a major feature. It tells the reviewer where to look hardest.
- 02Grant read-only accessRead-only roles on the repository with its full git history, hosting, CI, error tracking, and a staging database or a schema-only dump. The reviewer shouldn't need write access, production credentials, or copies of customer data.
- 03Share what existsThe README, any architecture notes or architecture decision records, a list of third-party services and where their keys are stored, and the problems you already know about. Rough notes are fine.
- 04Name a decision-makerThe person who will act on the report should join the kickoff and the walkthrough. A report that reaches the decision-maker second-hand tends to sit unread.
- 05Name a technical contactOne person who knows the system's history and can answer questions within a day during the review. Questions come up throughout the review.
Never send secrets by email or chat
A reviewer checks how secrets are stored without needing their values. If anyone asks for production passwords or API keys in a message, say no and grant a scoped, read-only role instead.
Checks you can run before the audit
#You can preview a few common findings yourself. The first command lists who has committed in the last year. If one name holds almost every commit, the audit will flag that knowledge risk. The other two show which .env files are tracked now, and which were ever committed on any branch.
git shortlog -sn --since='12 months ago' HEAD
git ls-files | grep -E '(^|/)\.env'
git log --all --name-only --format= | grep -E '(^|/)\.env' | sort -uIf the history check turns up a real key, rotate it before the audit starts. Our guide to exposed API keys walks through the cleanup. If the product uses Postgres behind an auto-generated API, such as Supabase, also list the tables with row-level security switched off. Supabase's documentation states the risk directly: a table in an exposed schema without row-level security is readable and writable by any role with a grant on it.
select tablename
from pg_tables
where schemaname = 'public'
and not rowsecurity
order by tablename;An empty result doesn't settle the question. A policy of using (true) for the anon role lets every signed-out visitor read the rows that role can reach, so the review reads each policy as well as the switch.
How long does a code audit take?
#A focused code audit of one web app and one database takes about 3 to 5 days of review. The calendar time from first call to walkthrough is longer, because scope, payment, and access come before the review starts.
- 01Discovery callAbout 45 minutes on what prompted the audit, the decision it should inform, and how the system looks today.
- 02Scope in writingThe questions the report will answer, the fee, and the start date, confirmed before anyone grants access.
- 03Access and kickoffRead-only roles are granted, and a short kickoff with the technical contact fills in the history the code can't show.
- 04ReviewAbout 3 to 5 days across code, architecture, infrastructure, and workflow, with questions sent as they come up.
- 05Report and walkthroughThe written report, then a call to go through the ranked findings and the build path.
What makes an audit take longer
#- Several repositories or services instead of one app and one database.
- A mobile app alongside the web app.
- Many integrations, data pipelines, or background jobs.
- AI features whose prompts, retrieval, and evals need their own review.
- Access that takes days to arrange, or a technical contact who is away during the review.
If the audit has to land before a fundraise or a board meeting, agree the start date when you agree the scope, and set up access before that date.
Is a software audit useful for investors?
#A software audit is useful before investors look, but it doesn't replace their review. Investors who run technical due diligence choose their own reviewer and get a report written for them. An audit you commission shows you the same kinds of findings first, while there is still time to act on them.
- The urgent findings get fixed before anyone outside the company sees them.
- The summary for non-engineers can go to investors or the board as it is.
- The build path shows the team knows what comes next and roughly what it costs, which is easier to defend than a list of unknowns.
The startup security checklist covers the basics investors and enterprise buyers tend to ask about, and it works as a first pass before an audit.
How do you use the audit result?
#Use the audit result to put the work in order. The walkthrough call should end with an agreed next step and a named owner for it.
- 01Start the fix-now groupBegin these straight away, even while the rest of the plan is still being discussed.
- 02Turn the build path into milestonesGive each step an owner and a date. The rough costs show what fits this quarter's budget and what moves to the next.
- 03Decide who does the workYour own team, a new hire, or an outside partner. A good report is written so any competent engineer can act on it.
- 04Make the rebuild call with evidenceIf the findings cluster in the foundations, such as the data model or the tenant boundary, compare the cost of fixing with the cost of rebuilding. Our guide on whether to rebuild or refactor sets out the trade-off.
- 05Stop the worst findings coming backAdd a test, a CI check, or a database policy for each fix-now finding, so a later change can't quietly undo it.
For findings that are real debt but not urgent, the technical debt triage checklist helps sort what to pay down now and what can wait. If one step in the build path is risky, such as an AI feature or a hard integration, a pilot sprint can prove it at a fixed price before a bigger commitment.
What should you do next?
#Start with the question you can't answer yet. If you built the first version fast with AI tools and want a quick self-check, work through the AI-built app risk checklist. If a fundraise, rebuild, or hiring decision depends on the state of the code, an outside audit gives that decision evidence instead of opinions.
Pixelact software audits are a fixed package from $2,500, and you can ask for the sample report we made from one of our own products to see the format before you pay.