A software code audit is a scoped review of an existing codebase and the evidence around it, undertaken to answer a delivery decision. A founder might need to know whether a product can support its next release, what a new team must fix before taking responsibility, or which parts of an estimate depend on unverified assumptions.
The useful output is a report that connects findings to the reviewed version, affected user journeys, evidence, limitations and next actions. A scanner score or a list of style warnings cannot supply that context on its own. This guide explains how to commission the review and assess its results. Use the editable code audit preparation checklist to collect the inputs.
Define the decision before the audit scope
Write the decision in one sentence. For example: “Can a receiving team safely maintain the booking service, and what must be resolved before it takes over?” That question needs evidence about deployment, tests, dependencies and operational ownership as well as source code. A narrower question about a particular integration needs a different scope.
Name the repositories, release or commit, environments, critical journeys and excluded components. Identify who can authorise access and who will receive the findings. Record whether the review includes running the build, executing tests, inspecting deployment configuration or reviewing a sample of production telemetry. Missing access is a limitation to report, not a reason to assume the component is healthy.
If the decision concerns investment in or acquisition of a software business, use the broader software technical due diligence guide. A code audit can supply technical evidence within that process; it does not establish the whole business case.
What should a software code audit cover?
| Review area | Evidence to inspect | Question for the report |
|---|---|---|
| Architecture and change boundaries | Module responsibilities, dependency direction and one critical request path | Which changes cross many components or rely on undocumented behaviour? |
| Business behaviour | Implemented rules, failure states and authorised test scenarios | Does the reviewed journey preserve the behaviour users depend on? |
| Tests and build | Reproducible build instructions, test results and coverage of critical outcomes | What can the receiving team verify, and what remains untested? |
| Security boundaries | Identity, authorisation, secret handling, input boundaries and selected controls | Which checks were actually performed and against which requirements? |
| Dependencies | Package manifests, lockfiles, provenance, support status and relevant advisories | Which dependencies need investigation or change, and why? |
| Delivery and operation | Deployment, migrations, monitoring, backup and recovery evidence | Can the responsible team release and recover the agreed version? |
Agree depth as well as topic names. “Review security” could mean checking selected source paths, running a tool, verifying specified controls or commissioning a separate penetration test. Those are different activities with different evidence. List exclusions and who owns any specialist follow-up.
Google's code review guidance discusses design, functionality, complexity, tests and documentation when reviewing a change. Those are useful review dimensions, but a change review is not a complete product assessment. State which parts of the system your audit actually covers.
Manual review, automated tools and security testing
Tools can identify candidates for investigation: a vulnerable dependency, a suspected secret, repeated code or a pattern that may be unsafe. Reviewers need to assess whether the result applies to the deployed system, how the code is reached and what evidence supports the stated impact. Keep false positives and unresolved results separate from verified findings.
Manual review adds product context. An apparently valid database query can still expose another customer's record if the surrounding authorisation rule is wrong. A clean static-analysis run does not show that the receiving team can restore the database or that the main booking journey survives a failed external service.
OWASP ASVS provides security verification requirements for web applications and services. If requirements from it are used, record the version, selected scope and verification evidence. Referencing the standard does not make a code audit an ASVS certification or prove that every control was tested.
Use authorised environments and agreed test data. Access should support the review without silently granting permission to change production, inspect unrelated customer information or run disruptive tests. Define how sensitive evidence is shared and removed when the engagement ends.
What an actionable audit report should contain
Ask for an executive decision summary followed by traceable findings. The summary should explain what was reviewed, what was demonstrated, the most important unresolved risks and which next decisions the evidence supports. It should retain the uncertainties rather than hiding them behind a single score.
- Review baseline: repositories, commit or release, environment, dates, reviewers and authorised scope.
- Method and coverage: paths inspected, tools and configurations used, tests executed and unavailable evidence.
- Finding register: observed behaviour, evidence location, affected journey, impact, confidence and verification status.
- Priorities: the reason a finding should be addressed now, investigated or deferred; severity and repair effort are different attributes.
- Action plan: proposed next action, dependencies, receiving owner and the test that would demonstrate resolution.
- Limitations: excluded systems, inaccessible services, unrun tests and assumptions that remain open.
Distinguish “not found within this scope” from “does not exist.” A review of selected payment paths cannot establish that every integration is safe. Likewise, the existence of a backup schedule is different from a demonstrated restoration. The handover checklist records the operational evidence separately.
Illustrative finding: a booking permission boundary
This is an invented example, not a finding from an EmphaSoft client. Assume a reviewer uses approved test accounts for two separate businesses. In the reviewed version, one account can retrieve a booking belonging to the other business through a path that lacks the expected ownership check.
| Report field | Example entry |
|---|---|
| Baseline and evidence | Reviewed commit, authorised test environment, affected handler and a restricted test-result record |
| Observed result | The second business's test booking is returned to the first account |
| Impact and uncertainty | Customer-record isolation fails on that path; the review has not established coverage of other paths |
| Next action | Engineering owner checks the authorisation boundary and related access paths before approving the affected release |
| Closure evidence | Tests show that the unrelated account is denied while the authorised owner retains the intended access |
The report does not need customer data or credentials in its summary. It needs enough safe, reproducible evidence for the authorised team to understand the finding, fix the correct boundary and verify the result. Avoid treating “add a permission check” as a complete estimate before reviewing related behaviour.
What affects audit effort and cost?
Repository count and lines of code are incomplete inputs. Review depth, languages, architecture, access quality, build reproducibility, critical journeys, deployment complexity and the amount of evidence to verify all affect the work. A small codebase with unclear external dependencies may need substantial investigation.
Request a scoped proposal identifying included activities, outputs, assumptions, unavailable inputs and the route for extending the review. Separate the assessment from remediation and retesting. Do not infer a repair budget from the number of findings: one ownership or migration problem may affect more work than many local corrections.
Use our cost guide to examine effort and rate assumptions and the SOW checklist to record acceptance of the audit deliverables. A useful acceptance example is that each reported finding names evidence and a next decision, rather than promising that the application will be defect-free.
From audit findings to a delivery plan
Separate immediate containment, further investigation, stabilisation and planned product improvements. Identify changes that depend on understanding existing behaviour before restructuring code. Agree what can continue safely while an issue is resolved and who can approve the next release.
An audit does not automatically justify a rewrite. Use the rewrite-or-refactor framework to examine the affected boundaries, compatibility and migration work. The maintenance guide covers continuing responsibilities after the initial assessment.
A published example of joining an existing project
The Sourcefit case records a project audit and EmphaSoft joining an existing development team, contributing backend, frontend, technical leadership and DevOps. It illustrates the setting in which a receiving team needs to understand an existing system. The published account does not disclose audit findings, a report or an audit price; the booking example above is independent of it.
Frequently asked questions
Is a code audit the same as code review?
A routine review usually assesses a proposed change. An audit is commissioned around an agreed system scope and decision, with explicit coverage, findings and limitations. Confirm what the supplier means by either term.
Can automated tools complete the audit?
They can provide useful evidence, but cannot by themselves establish product behaviour, ownership, operating capability or the relevance of every warning. Ask which results a reviewer validates and which remain unverified.
What should we prepare before the review?
Identify the release, repository owners, build instructions, relevant environments, critical journeys, known incidents and the decision you need to make. Use the preparation worksheet to record access and evidence gaps.
Discuss the scope of your review
Tell EmphaSoft what product you operate, which decision is blocked and which repositories and environments are available. We can discuss an assessment scope and the evidence it should deliver. Discuss your codebase.