Skip to content

[ Anolilab — Article / Software development ]

Technical code audit: what it checks and when you need one

Before an investment, after a handover or when your app keeps breaking: what a technical audit checks, which tools help and what belongs in the report.

Article by
Daniel Bannert · Founder · Anolilab

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

AreaKey questionTypical evidence
ArchitectureDoes the structure fit what the software has to do today?Dependency graph, module boundaries, data flow
Code qualityCan the code be changed safely?Complexity, duplication, dead code, type errors
Dependencies and licencesWhat is in the software, and may you use it that way?SBOM, known vulnerabilities, licence list
SecurityAre the basics covered?Access checks, secrets in the repository, configuration
PerformanceWhere does the app lose time?Database queries, bundle size, load tests
Tests and CI/CDDoes the team notice a bug before the customer does?Test coverage, pipeline, deployment process
Infrastructure and costsIs operation stable and reasonably priced?Hosting, backups, monitoring, invoices
Documentation and bus factorDoes 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.

ToolWhat it doesLicence
Semgrep Community EditionStatic analysis for insecure patterns, more than 1,000 community rulesLGPL-2.1
SonarQube Community BuildCode quality, duplication, test coverage, quality gatesLGPL-3.0
dependency-cruiserDependency graph and architecture rules for JS/TSMIT
KnipUnused files, dependencies and exports in JS/TSISC
OSV-ScannerKnown vulnerabilities in dependencies, data from osv.devApache-2.0
Syft and GrypeGenerate an SBOM (CycloneDX, SPDX) and scan it for vulnerabilitiesApache-2.0
ScanCode ToolkitFind licences and copyright notices in codeApache-2.0
GitleaksSecrets in the code and in the Git historyMIT
OpenSSF ScorecardRates open-source dependencies, for example whether they are maintainedApache-2.0
Grafana k6Load tests with scripts in JavaScriptAGPL-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:

  1. Summary for decision-makers. One page: what state the software is in, the three biggest risks, and what follows for the decision at hand.
  2. Prioritised findings. Each finding with severity, location in the code and the reason it matters. Sorted by impact, not by audit area.
  3. Effort estimate per finding. Rough enough to plan with, such as small, medium or large. Only then can you decide what comes first.
  4. Concrete fixes. What exactly to change, ideally with a code example. "Improve security" is not a fix.
  5. 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?

  1. 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.

  2. 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.

  3. 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.

  4. Name a contact person

    Someone who can answer questions about the business logic. After a handover, ideally also a contact on the previous team.

  5. Run a first scan yourself

    npx knip, osv-scanner scan source -r . and gitleaks 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.

Related articles.

[ Anolilab — Contact ]

Tell me what you're building. I'll tell you how I can help.

Let's talk.

Quick response.
If you're ready to create and collaborate, I'd love to hear from you.
Clear next steps.
After the consultation, I'll give you a detailed plan.
Alternatively, you can email me directly at hello@anolilab.com