In short
A technical code audit answers one question: can this software carry what you plan to do with it next? It checks architecture, code quality, dependencies and licences, security, performance, tests and deployment, infrastructure and costs, and documentation and how knowledge is spread across the team. You need one before an investment or acquisition, before you scale, after an agency or freelancer hands the project over, before you decide on a rewrite, and when the same bugs keep coming back. The result is a prioritised list with effort estimates and concrete fixes, not a 50-page PDF.
Most pages about technical audit services sell the audit without saying what happens in it. This article lays out the areas an audit covers, the tools used for each, and how to tell a useful report from a useless one, so you can compare offers or prepare yourself.
What is a technical code audit?
In a technical audit, someone who did not build the software reads the code, the dependencies, the pipeline and the infrastructure, and judges them against a goal. That goal is usually maintainability. The ISO/IEC 25010 standard defines it as how effectively and efficiently a product can be changed to improve it, fix it or adapt it to new requirements, and splits it into modularity, reusability, analysability, modifiability and testability (ISO 25000 portal, checked November 2026).
A security audit or penetration test is narrower: it looks for ways to break into the app. A technical audit covers the security basics, but it also asks whether the team will still ship features quickly a year from now. What a security audit of AI-generated code looks like is covered in Is AI-generated code secure?.
When do you need a technical audit?
An audit pays off whenever a decision involving money or time depends on the quality of the code:
- Before an investment or acquisition. In technical due diligence, the buyer wants to know which risks come with the deal: licences, security gaps, dependence on individual people, and how much rework the product needs after closing.
- Before scaling. When 100 users are meant to become 10,000, or the team grows from two people to eight, every shortcut from the early days shows.
- After a handover. An agency or freelancer has finished the project and your team is taking over. An audit shows what you are inheriting while you can still ask the people who built it.
- Before a rewrite decision. "Let's rewrite everything" is an expensive call. An audit separates the parts that really need replacing from the ones that can be refactored in place.
- When the app keeps breaking. The same bugs return after every fix, releases are a gamble, and nobody wants to touch certain files. The cause then usually sits deeper than the individual bug.
For a startup, the first two usually come together: a funding round brings both investor questions and the plan to grow.
What a technical audit checks
| Area | Key question | Typical evidence |
|---|---|---|
| Architecture | Does the structure fit what the software has to do today? | Dependency graph, module boundaries, data flow |
| Code quality | Can the code be changed safely? | Complexity, duplication, dead code, type errors |
| Dependencies and licences | What is in the software, and may you use it that way? | SBOM, known vulnerabilities, licence list |
| Security | Are the basics covered? | Access checks, secrets in the repository, configuration |
| Performance | Where does the app lose time? | Database queries, bundle size, load tests |
| Tests and CI/CD | Does the team notice a bug before the customer does? | Test coverage, pipeline, deployment process |
| Infrastructure and costs | Is operation stable and reasonably priced? | Hosting, backups, monitoring, invoices |
| Documentation and bus factor | Does everything depend on one person? | README, architecture notes, commit history |
Architecture
This is about the big lines: where the business logic lives, how modules depend on each other, and whether there are circular dependencies where every change in one place breaks three others. In JavaScript and TypeScript projects, dependency-cruiser makes this visible: it draws the dependency graph and reports circular dependencies, orphaned files and production code that relies on development packages (checked November 2026).
Code quality and maintainability
Static analysis reads the code without running it and finds patterns such as overly complex functions, copied code or unused exports. SonarQube has a free community edition; its default "Sonar way" quality gate requires, among other things, no new issues, at least 80% test coverage and at most 3% duplication on new code (Sonar documentation, checked November 2026). Knip finds unused files, dependencies and exports in JavaScript and TypeScript projects.
Tools only deliver metrics. Whether a complex function is a problem depends on how often it changes and how much depends on it. That judgement is the part a person has to make.
Dependencies and licences
Modern software is mostly other people's packages. An audit therefore produces a software bill of materials (SBOM), which the US agency CISA describes as a "nested inventory, a list of ingredients that make up software components" (CISA, checked November 2026). Two checks run against that list:
- Known vulnerabilities: is there a published flaw in a version you use, and is a fixed version available?
- Licences: does each package's licence allow the way your product uses it? A typical finding in SaaS products is AGPL-licensed code. If you modify it, section 13 of the licence requires you to offer the source of your version to all users who interact with it over a network (GNU AGPL v3, checked November 2026). Whether that matters in your case is a question for a lawyer; this is not legal advice.
In the EU, the SBOM becomes mandatory for manufacturers of products with digital elements. The Cyber Resilience Act requires a software bill of materials "in a commonly used and machine-readable format" covering at least the top-level dependencies. That duty applies from 11 December 2027; the reporting obligations under Article 14 have applied since 11 September 2026 (Regulation (EU) 2024/2847, Annex I Part II and Article 71, checked November 2026). Germany's Federal Office for Information Security (BSI) sets out SBOM requirements in its technical guideline TR-03183 part 2 (checked November 2026).
Security basics
A technical audit does not replace a penetration test, but it checks the things that go wrong most often. The OWASP Top 10:2025 works as a grid: broken access control is in first place, and software supply chain failures, meaning exactly the dependencies from the previous section, are new in third place (checked November 2026). For a deeper check, use the OWASP Application Security Verification Standard 5.0, published on 30 May 2025, which also works as a list of requirements for contracts (checked November 2026).
Then there are secrets in the code. Gitleaks also searches the Git history for passwords, API keys and tokens, because a deleted key is still in old commits (checked November 2026). The checks for AI-built apps on Supabase, Lovable or Cursor are covered in detail in the article on the security of AI-generated code.
Performance
Slow pages rarely have a single cause. An audit measures where time is lost: database queries without an index or inside loops, oversized JavaScript bundles, third-party scripts, missing caching. For load tests, Grafana k6 is an open-source tool whose test scripts are written in JavaScript (checked November 2026). How to measure load times in the browser and improve them against Google's thresholds is in Improving Core Web Vitals.
Tests and CI/CD
The question is not whether tests exist but whether they catch the bugs that cost you money. An audit therefore looks at which flows are tested (payment, login, data export), whether tests run on every pull request, and how a deployment works. For the delivery process, the metrics from Google's DORA research programme help, such as the time from a commit to production and the share of deployments that need immediate intervention (DORA, checked November 2026).
Infrastructure and costs
This is about operations: where does the software run, are there backups, and has anyone ever tested a restore? Is there monitoring that reports an outage before a customer calls? And do the hosting bills match the actual load? Oversized servers, forgotten test environments and expensive managed services for small workloads are common cost drivers. Whether a cheaper provider fits is covered in the comparison of VPS providers.
Documentation and bus factor
The bus factor (also called truck factor) is the smallest number of developers who have to drop out before a project can no longer be developed further. A study of 133 popular GitHub projects found a truck factor of two or less in 65% of them (Avelino et al., ICPC 2016, checked November 2026). In a small company project it can be a single person. An audit reads the commit history for this, checks whether the project starts locally by following the README, and whether architecture decisions are written down anywhere.
Which tools help with an audit?
Every tool in this table is open source or has a free edition. None of them pays a commission.
| Tool | What it does | Licence |
|---|---|---|
| Semgrep Community Edition | Static analysis for insecure patterns, more than 1,000 community rules | LGPL-2.1 |
| SonarQube Community Build | Code quality, duplication, test coverage, quality gates | LGPL-3.0 |
| dependency-cruiser | Dependency graph and architecture rules for JS/TS | MIT |
| Knip | Unused files, dependencies and exports in JS/TS | ISC |
| OSV-Scanner | Known vulnerabilities in dependencies, data from osv.dev | Apache-2.0 |
| Syft and Grype | Generate an SBOM (CycloneDX, SPDX) and scan it for vulnerabilities | Apache-2.0 |
| ScanCode Toolkit | Find licences and copyright notices in code | Apache-2.0 |
| Gitleaks | Secrets in the code and in the Git history | MIT |
| OpenSSF Scorecard | Rates open-source dependencies, for example whether they are maintained | Apache-2.0 |
| Grafana k6 | Load tests with scripts in JavaScript | AGPL-3.0 |
Details as of November 2026. To keep dependencies current after the audit, use Dependabot on GitHub or Renovate on almost any Git platform. As an SBOM format, CycloneDX is now standardised as ECMA-424.
A tool run is not an audit, though. On a mature project, a scanner quickly reports hundreds of findings, and most of them do not matter for your decision. The value of an audit lies in finding the few points that really count.
What a good audit report contains
A useful report is short enough to be read and specific enough that someone can work from it. Look for these parts:
- Summary for decision-makers. One page: what state the software is in, the three biggest risks, and what follows for the decision at hand.
- Prioritised findings. Each finding with severity, location in the code and the reason it matters. Sorted by impact, not by audit area.
- Effort estimate per finding. Rough enough to plan with, such as small, medium or large. Only then can you decide what comes first.
- Concrete fixes. What exactly to change, ideally with a code example. "Improve security" is not a fix.
- What is good. Parts that are solid and should stay. This matters most before a rewrite decision.
A 50-page PDF of generic recommendations and unfiltered scanner output is the opposite. I would ask for an anonymised sample report before hiring anyone for a technical code audit.
How do you prepare for an audit?
Define the goal
Write down in two sentences which decision the audit should support: investment, acquisition, scaling, rewrite or bug hunting. That decides which areas get a deep look.
Prepare access
Read access to the repositories, the CI/CD pipeline and the hosting, ideally through separate accounts with an expiry date rather than shared passwords.
Collect known problems
A short list of the bugs that keep coming back, the slow pages and the files nobody wants to touch. That saves search time.
Name a contact person
Someone who can answer questions about the business logic. After a handover, ideally also a contact on the previous team.
Run a first scan yourself
npx knip,osv-scanner scan source -r .andgitleaks git -v .show you within minutes where you stand and make the audit's results easier to put in context.
Technical audit checklist
- Does the project start on a fresh machine by following the README?
- Are there circular dependencies or modules that connect everything to everything?
- How many dependencies have known vulnerabilities, and how outdated are they?
- Is there an SBOM, and do all licences fit the way the product is used?
- Are keys or passwords in the code or the Git history?
- Does the server check on every request whether the user may see the data?
- Are payment, login and other business-critical flows covered by automated tests?
- Do tests run on every pull request, and does a failure block the deployment?
- Are there backups, and has a restore ever been tested?
- Does monitoring report outages before customers do?
- Do hosting costs match the actual load?
- Do at least two people know every important part of the system?
Check it yourself or get an audit?
The checklist and the tools are enough to find the obvious problems yourself. An external audit is worth it when a decision with a lot of money depends on it, when nobody on the team can interpret the scanner results, or when the team knows its own code too well to read it with fresh eyes. In a purchase or investment, the selling side also rarely judges its own code neutrally.
[ Anolilab — Blog ]
More hands-on writing on AI, web development and infrastructure.
