What Should an Inherited Codebase Audit Check?
What should an inherited codebase audit establish?
An inherited codebase audit checklist should establish whether your software can be built, operated, tested and changed safely. It should cover reproducible setup, dependency health, deployment access, critical user workflows and the evidence behind each finding. The result should separate verified defects from concerns that need investigation and areas nobody examined.
For a founder or product owner, the useful outcome is a decision: what needs attention before development continues, what can wait, and what remains unknown.
What belongs on the audit checklist?
Ask the reviewer to agree on the scope before examining the software. Identify the product being assessed, the version under review, the important user journeys and any access restrictions.
Use this checklist to define the expected evidence.
| Area | What to check | Evidence to request |
|---|---|---|
| Setup | Can someone start from a clean machine? | Recorded setup steps and a successful build |
| Dependencies | Are required packages understood and maintainable? | Inventory, support checks and unresolved concerns |
| Access | Can authorised people operate and release the product? | Verified ownership, permissions and recovery routes |
| Workflows | Do essential user journeys produce correct outcomes? | Expected and observed results |
| Tests | Can checks detect meaningful failures? | Test results and a demonstrated failing case |
| Operations | Can failures be detected and recovery performed? | Alert review and a controlled recovery exercise |
| Change safety | Can a small change be checked and reversed? | A representative change in an isolated test setting |
| Findings | What should happen next? | Priorities, evidence, scope limits and closure criteria |
A document saying each area was “reviewed” is insufficient. Ask what was attempted, what happened and what could not be checked.
Can someone reproduce the setup and build?
Start with a clean setup, using the instructions a new maintainer would receive. Avoid relying on a departing developer's already configured machine.
Ask the reviewer to:
- Identify the required runtime, package manager and supporting services.
- Install the intended dependency versions.
- Create safe sample data without copying private customer records.
- Run the application and produce a release build.
- Record missing instructions and any manual intervention.
Treat each result precisely. “Started after undocumented steps” is different from “setup reproduced successfully.” If access to a required service is missing, record a blocked check rather than concluding that the application is broken.
The handover should include corrected setup instructions and a clear account of anything still needed. The acceptance condition is that another authorised person can repeat the process.
Are the dependencies understood and supportable?
Ask for an inventory of direct dependencies and a review of important indirect dependencies. For each significant component, check its purpose, installed version, maintenance status, licence obligations and available support information.
Keep different concerns separate. An available update is an upgrade decision. A confirmed incompatibility is a reproducible defect. A reported security concern needs assessment against the component actually used and how the product uses it.
Request authoritative references for support or security claims in the private audit report. Do not accept a list of automated warnings as a finished assessment.
Avoid making a broad upgrade part of the audit by default. First establish the current build, identify changes that are necessary, and define how their effects will be checked. Our guide to technical debt for founders provides related context for deciding which maintenance work deserves attention.
Does the business control deployment and recovery?
Check that the business controls the accounts needed to run and release its product. Include the source repository, hosting, domain registration, data storage and essential outside services within the agreed scope.
Verify permissions through authorised access rather than collecting passwords in the report. Ask who can approve releases, recover an account and remove a former supplier's access.
Then examine the release and recovery procedure:
- Can the reviewed version be deployed to an isolated test setting?
- Is there a clear way to identify what is running?
- Can a failed release be reversed?
- Are data changes considered separately from application changes?
- Can a backup be restored and its contents checked?
- Does someone receive and act on a meaningful failure alert?
Ask for controlled demonstrations where appropriate. Do not perform disruptive recovery exercises against live customer activity merely to complete the checklist.
Do the critical workflows work from beginning to end?
Choose workflows by business consequence. Ask what customers must be able to complete and which errors would create the most harm.
Depending on the product, the selection might include registration, account recovery, purchasing, cancellation, permission changes or exporting records. Follow each selected journey through to its final result, including any document, message or external handoff it produces.
For each workflow, record:
- The starting conditions and user permissions.
- The action taken.
- The expected outcome.
- The observed outcome.
- Whether the result was checked beyond the screen.
Include failure paths. Try invalid input, interrupted requests, repeated submissions and access by the wrong user role where those cases fit the product.
Use synthetic records and approved test accounts. Define boundaries for activities that could charge money, contact customers or alter real records.
Can the tests detect a real failure?
Ask which important behaviours the tests cover and which they leave unexamined. Record whether the checks actually ran, whether any were skipped and whether outside services were replaced with test substitutes.
For a representative check, introduce a controlled incorrect result in an isolated copy and confirm that the check fails. Restore the correct behaviour afterwards. This provides evidence about that check; it does not establish that the whole test suite is effective.
Next, select a small representative change. Ask whether its effect can be tested, reviewed and reversed without unrelated edits. Trace the affected behaviour through the relevant parts of the application.
The question is whether the next maintainer can change a behaviour with evidence that it still works. Read more about evaluating these checks in software testing and quality assurance.
How should findings distinguish defects from unknowns?
Use explicit status labels throughout the report.
| Status | Meaning | Required next step |
|---|---|---|
| Verified defect | Observed behaviour contradicts an agreed requirement | Record reproduction steps and a correction check |
| Concern requiring verification | Evidence suggests a problem, but its effect is unconfirmed | Define the investigation needed |
| Blocked | A planned check could not proceed | State the missing access or prerequisite |
| Not examined | The area was outside the completed review | State the boundary and whether further review is recommended |
| Passed within scope | The stated check produced its expected result | Preserve the evidence and limits |
Keep status separate from priority. An unexamined recovery procedure may deserve urgent investigation without being described as a failed recovery.
For every verified defect, request the affected behaviour, expected result, observed result, business consequence and evidence. Keep sensitive technical details in the restricted report.
How should the findings be prioritised?
Prioritise by consequence, exposure and the work needed to establish or restore safe operation. Explain the reasoning instead of assigning a severity label alone.
An illustrative handover might recommend:
- Before the next release: correct a reproduced permission failure and add a check that detects it.
- Before a major feature: demonstrate recovery where the audit could not verify it.
- During planned maintenance: assess a supported dependency update with no observed product failure.
- When the affected area changes: simplify confusing code whose behaviour passed the agreed checks.
These are examples, not findings about your product. Each recommendation should name a responsible role, a completion condition and any prerequisite.
What common mistakes should you avoid?
Treating unfamiliar code as defective. Ask for an observed consequence or a clearly stated maintenance concern before approving a rewrite.
Equating a successful build with a working product. Keep build evidence separate from workflow and operational evidence.
Presenting every warning as equally urgent. Require assessment and prioritisation.
Leaving omissions implicit. List excluded components, inaccessible services and untested workflows.
Turning the audit into an open-ended rebuild. Request a bounded action plan tied to the evidence.
What else do founders ask?
Does an audit need to examine every line?
Define coverage around the decision you need to make. Identify which workflows and components receive detailed examination, and list the remainder explicitly.
Can an audit justify replacing the application?
Ask for evidence that connects the problems to replacement. Compare targeted repairs, gradual replacement and a rebuild, including how each option would preserve essential behaviour.
What should the final deliverable contain?
Request an executive decision summary, the completed checklist, reproducible findings, an access and ownership summary, scope limits and a prioritised action plan.
When is the audit complete?
Close the audit when the agreed checks have documented outcomes and the remaining unknowns are explicit. Keep remediation separate: identifying a defect does not mean it has been fixed.
*Taking over an existing product? Discuss an inherited codebase review →*