Skip to main content
Web securityReviewed

Secure code review for web applications, checked against the running build

A security review of the source code behind your web application and its API.

It follows the paths in scope that read or change data, looking at authorisation, secrets, untrusted input, dependencies and the assumptions AI-written code leaves unchecked. Code findings are confirmed against a running build where the scope allows, and the report marks any that rest on the code alone.

What a secure code review is for

A secure code review reads an application's source to find the flaws that let someone do what the business never meant to allow: read another customer's records, change a price, reach an admin function or lift a key.

Buyers also call it a security code review, a source code security review or a code security audit. Whatever the label, the work is the same. Follow each way into the application to the data it touches, and check the rules the code is supposed to enforce along the way.

That is a different question from the one an ordinary pull request review asks. A colleague reviewing a change checks that it works, reads clearly and fits the codebase. A security reviewer reads the same change as someone who wants to misuse it: what happens if the id belongs to somebody else, if the request skips the screen, or if a field the form hides is sent anyway. Both reviews are worth doing, and neither stands in for the other.

OWASP's Secure Code Review Cheat Sheet describes two shapes of review. A baseline review examines an entire codebase, and a diff-based review examines only the changes. The cheat sheet suggests baseline reviews for high-risk components and diff-based reviews for routine changes, with a move from one to the other when a change raises significant security concerns. It also places code review beside automated SAST and DAST tools as a complement, not a substitute.

Clever Ops reviews code for custom web applications and their APIs, such as Next.js, React and Node applications, using read-only access to your repository. The written scope names what is read: an area of the codebase, such as the authorisation layer and every route that returns customer data, or a defined set of changes, such as a feature branch before release.

If Clever Ops built or hosts the application, the work is called a security review, not an independent one, and the report states who built it and who hosts it.

What the reviewer reads for

On a web application the review reads for four things, plus a fifth when an AI tool wrote part of the code, covered in the next section.

Each area has a matching block in the review checklist at the end of the annotated example.

Authorisation on every data path

The review lists each way into the code in scope that reads or writes data: route handlers, Server Actions, pages that query directly, webhooks, background jobs, exports and search. 1 min read

Secret handling

The review looks for keys, tokens, passwords and connection strings wherever they can sit: source files, test fixtures, seed scripts, configuration, build output and the history of the branches in scope. 1 min read

Untrusted input

Everything a request carries can be edited before it is sent: path segments, query strings, headers, cookies, form fields and JSON bodies. 1 min read

Dependencies and the build

OWASP Top 10:2025 widened its old category for vulnerable and outdated components into A03 Software Supply Chain Failures, which takes in compromises across software dependencies, build systems and distribution infrastructure. 1 min read

AI code security review: checking what the tool assumed

On this page, an AI code security review means a security review of code written with an AI coding assistant or agent.

The flaws in AI-written code are familiar ones. What changes is how much of the surrounding evidence came from the same tool: the code, the pull request description that explains it, the tests that pass against it and the packages it chose.

OWASP's Secure Coding with AI Cheat Sheet treats each of those as something to verify. It says to review every file in an agent-generated pull request individually rather than approving on the description alone, and it warns that a passing test suite generated by the same agent that produced the code provides no independent assurance.

It also describes agents making CI green by deleting failing tests or weakening assertions instead of fixing the code.

Dependencies get the same treatment. The cheat sheet notes that AI coding assistants frequently suggest package names that do not exist on public registries, that attackers register those names with malicious packages, and that suggested versions can be ones that were current during training but now have known vulnerabilities. Its advice is to confirm that every suggested package exists before installing it and to check versions against vulnerability databases.

The review checks these assumptions in AI-written changes, because code can look finished while resting on them:

  • The list screen only shows the user's own records, so the detail route needs no check. A route can be requested without the list.
  • Signed in means allowed. Authentication establishes who is calling, and says nothing about which records that person may touch.
  • The id is random, so nobody can guess it. OWASP's IDOR prevention guidance treats complex identifiers as defence in depth and says access control checks are still essential.
  • The description says the input is validated upstream. The review finds that validation, or reports that it is missing.
  • The tests pass. The review reads what the tests assert, and whether any of them expects a refusal.
  • The framework call matches the installed version. In Next.js route handlers, for example, params became a promise in version 15, so code written for an older release reads it differently.

Why each code finding goes back to the running application

Reading the code takes a review deeper than testing from the outside can reach.

It does not replace testing the running application, and a report that presents it as a replacement overstates what was checked. The WSTG v4.2 introduction gives both halves of the reason: among the drawbacks of source code review, the code actually deployed might differ from the code analysed, and among the strengths of penetration testing, it tests the code that is actually exposed.

Configuration, environment variables, proxies, hosting rules and feature flags all change behaviour without appearing in the files under review, and OWASP's page on source code analysis tools notes that configuration issues are frequently missed for that reason.

So each code finding is taken back to a running build of the same commit where the scope allows. A suspected missing ownership check becomes a pair of requests: the owner reading their own record, and a test account in another organisation asking for the same one.

Confirmation uses test accounts and test records. Destructive actions are off by default for real people's accounts and records that existed before the test, and reset, lockout and deletion checks run only on test accounts and test records where the rules of engagement allow them.

Every finding then carries one of two labels. Confirmed on the running build means the request and response are in the report. Code only means the flaw was read but not reproduced, and the report gives the reason, such as no staging copy of that service, or a path that would have needed a destructive action on real data.

A code-only finding still deserves a fix; the label tells the reader exactly how far the evidence goes.

The reverse holds too. A test of the running application reaches only the routes it can find, and a route no screen calls can go unnoticed. Reading the routing files lists every entry point, so the two together cover more than either alone.

The Next.js data security guide makes the same pairing for two kinds of file it says have a lot of power: it asks for extra auditing time on proxy.ts and route.ts, and recommends penetration testing or vulnerability scanning regularly or in step with your development lifecycle.

The web application penetration testing page describes that test, with code access added where the riskiest logic sits in a few files.

Annotated pull request: one access-control flaw from diff to regression test

An invented Next.js pull request, written for this page and not taken from any client, traced through four views: the diff with review comments, the request that proves the flaw on a running build, the finding as the report records it, and the fix with the regression test that keeps it closed. A review checklist for authorisation, secret handling, untrusted input, dependencies and AI-written code follows, ready to copy into a pull request template.

secure-code-review.txt

ILLUSTRATION ONLY. The application, pull request, commits, accounts and data below were invented for this page. They are not a client's code, and the finding is not a client's result.

Stack: a Next.js App Router application (route handlers on Next.js 15 or later, where params is a promise), the Prisma ORM 7 client and a Playwright test suite. lib/session.ts holds the encrypt and decrypt helpers from the Next.js authentication guide.

The application schedules work for trades businesses. Each business is an organisation. Office staff create jobs for their customers, and crew members open job sheets on their phones. Every job row carries an organisationId. Customer rows hold a name, suburb, phone number, email address and site access notes.


## View 1 of 4: the diff, with review comments

Pull request #482: "Add job detail endpoint for the crew app"
Branch head: commit 7d41c2e
Description as submitted: "Adds GET /api/jobs/[jobId] so the crew app can load a job sheet. Only reachable from the jobs list, which is already filtered to the user's organisation. Signed-in check included. Test added."
Most of the change was generated by an AI coding assistant from a one-line prompt.

```diff
--- /dev/null
+++ b/app/api/jobs/[jobId]/route.ts
@@ -0,0 +1,23 @@
+import { getViewer } from '@/lib/dal'
+import { prisma } from '@/lib/prisma'
+
+export async function GET(
+  _request: Request,
+  { params }: { params: Promise<{ jobId: string }> },
+) {
+  const viewer = await getViewer()
+  if (!viewer) {
+    return Response.json({ error: 'Not signed in' }, { status: 401 })
+  }
+
+  const { jobId } = await params
+  const job = await prisma.job.findUnique({
+    where: { id: jobId },
+    include: { customer: true },
+  })
+  if (!job) {
+    return Response.json({ error: 'Not found' }, { status: 404 })
+  }
+
+  return Response.json(job)
+}
--- /dev/null
+++ b/tests/access/job-route.spec.ts
@@ -0,0 +1,8 @@
+import { test, expect } from '@playwright/test'
+
+test.use({ storageState: 'playwright/.auth/crew-org-b.json' })
+
+test('loads a job', async ({ page }) => {
+  const response = await page.request.get('/api/jobs/seed-job-org-b')
+  expect(response.status()).toBe(200)
+})
```

Comment 1, route.ts line 2. This route reads the database directly instead of through lib/dal.ts. Every other job read in the codebase goes through listJobsForViewer, which filters by organisation. The auditing advice in the Next.js data security guide is to check that database packages are not imported outside the Data Access Layer, and this import is the sign that the route skips the filter.

Comment 2, route.ts lines 14 to 17. The query selects the job by id alone. Lines 8 to 11 establish that someone is signed in, and nothing afterwards compares the job's organisationId with the viewer's. Any signed-in user who has a job id can read that job, whichever organisation owns it.

Comment 3, route.ts line 16. Prisma returns every scalar field of a model unless the query selects fields, and include adds the related customer record. The response therefore carries the customer's phone, email and access notes, which the crew screen never shows. Select only the fields the screen renders.

Comment 4, the description. "Only reachable from the jobs list" describes the screen, not the route. The Next.js authentication guide says to treat route handlers with the same security considerations as public-facing API endpoints: this one answers any browser or script that requests its URL. A random id does not change that. OWASP's IDOR prevention guidance calls complex identifiers a defence-in-depth measure and says access control checks are still essential.

Comment 5, job-route.spec.ts lines 5 to 8. The test shows a crew member loading a job in their own organisation. It has no case for a job in another organisation, so it passes on the flawed code and would pass on a fixed version alike. It proves the route works, not that it refuses.


## View 2 of 4: the runtime request that proves it

Where: staging, deployed from commit 7d41c2e, the head of the branch under review. The deployment record names the commit, so the code that was read and the code that answered are the same.
Accounts: office-a1 (office role, Org A) and crew-b1 (crew role, Org B). Both are test accounts.
Data: "Test job A-1" for "Test Customer A", created in Org A for this review. No real customer record was requested.

Request 1, the owner, for contrast: office-a1 requests GET /api/jobs/cm8a1test0job01 and receives 200 with the job. Expected.

Request 2, the other organisation:

```http
GET /api/jobs/cm8a1test0job01 HTTP/1.1
Host: staging.jobs-demo.test
Cookie: session=[redacted, crew-b1 in Org B]

HTTP/1.1 200 OK
Content-Type: application/json

{
  "id": "cm8a1test0job01",
  "organisationId": "org_a",
  "customerId": "cm8a1test0cus01",
  "title": "Test job A-1",
  "status": "SCHEDULED",
  "scheduledFor": "2026-11-20T23:00:00.000Z",
  "customer": {
    "id": "cm8a1test0cus01",
    "organisationId": "org_a",
    "name": "Test Customer A",
    "suburb": "Sale",
    "phone": "[redacted]",
    "email": "[redacted]",
    "accessNotes": "[redacted]"
  }
}
```

Expected for request 2: 404, the same response a job id that does not exist receives.
Observed: 200, with Org A's job and its full customer record. The phone, email and access notes were present in the response and are redacted here.

How crew-b1 had the id: the review held test accounts in both organisations and took the id from office-a1's own view. Outside a test, job ids travel in shared links, notification emails, exports and browser history. A hard-to-guess id slows guessing; it does not decide who may read the record.


## View 3 of 4: the finding as the report records it

FINDING CR-1: Any signed-in user can read another organisation's jobs and customer contact details

Status: open. Confirmed on the running staging build of commit 7d41c2e.
Location: app/api/jobs/[jobId]/route.ts, lines 14 to 17 (the findUnique call), commit 7d41c2e.
OWASP Top 10:2025: A01 Broken Access Control (CWE-639 Authorization Bypass Through User-Controlled Key).
Reviewed against: ASVS v5.0.0-8.2.2 (data-specific access) and v5.0.0-8.4.1 (cross-tenant controls). Test procedure: WSTG-v42-ATHZ-04.
Technical severity: CVSS v3.1 6.5, Medium. Vector: CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N
Business risk: High. On the code as read, customer phone numbers, email addresses and site access notes from every organisation can be read by any account that can sign in, including a crew member invited by a different business. In this application, access notes can hold gate and key-safe codes, so the exposure reaches customers' properties as well as their contact details.

What the code does: the handler confirms the caller is signed in (lines 8 to 11), then loads the job by id alone (lines 14 to 17). Nothing compares the job's organisation with the caller's. The organisation filter used by the jobs list lives in listJobsForViewer, which this route never calls.

Evidence: request 2 in view 2, with request 1 beside it for contrast. Personal fields are redacted.

Demonstrated: an Org B crew account read one Org A test job and its customer record on staging.
Inferred from the code, not demonstrated: the same read works for any job id in any organisation, because the query has no organisation condition. Writes are not affected, because the route file exports GET only.

Fix: read jobs through the data access layer. Add getJobForViewer(viewer, jobId) to lib/dal.ts with the organisation in the query's where clause, return only the fields the crew screen renders, and send the same 404 for a missing job and a job in another organisation. Add a regression test with a cross-organisation case.

Retest criteria:
1. Request 2, repeated on the fixed build, returns 404 with no job data.
2. Request 1 still returns 200 for the owner.
3. The cross-organisation test in tests/access/job-route.spec.ts fails on commit 7d41c2e and passes on the fix commit.
4. No route, Server Action or page under app/ reads jobs or customers through @/lib/prisma directly; those reads go through lib/dal.ts.


## View 4 of 4: the fix, and the regression test that keeps it fixed

The organisation check moves into the data access layer, next to the query, so every caller gets it.

```diff
--- a/lib/dal.ts
+++ b/lib/dal.ts
@@ -1,34 +1,49 @@
 import 'server-only'
 import { cache } from 'react'
 import { cookies } from 'next/headers'
 import { decrypt } from '@/lib/session'
 import { prisma } from '@/lib/prisma'
 
 export type Viewer = {
   userId: string
   organisationId: string
 }
 
 // The organisation comes from the user's own database record, never from
 // the request. React cache only deduplicates within a render pass; in a
 // route handler every call runs, so call getViewer once per request.
 export const getViewer = cache(async (): Promise<Viewer | null> => {
   const cookie = (await cookies()).get('session')?.value
   const session = await decrypt(cookie)
   const userId = session?.userId
   if (typeof userId !== 'string') return null
 
   const user = await prisma.user.findUnique({
     where: { id: userId },
     select: { id: true, organisationId: true },
   })
   if (!user) return null
   return { userId: user.id, organisationId: user.organisationId }
 })
 
 export function listJobsForViewer(viewer: Viewer) {
   return prisma.job.findMany({
     where: { organisationId: viewer.organisationId },
     select: { id: true, title: true, status: true, scheduledFor: true },
   })
 }
+
+// Pass only a Viewer returned by getViewer. The organisation condition is
+// part of the query, so a job in another organisation is not loaded.
+export function getJobForViewer(viewer: Viewer, jobId: string) {
+  return prisma.job.findFirst({
+    where: { id: jobId, organisationId: viewer.organisationId },
+    select: {
+      id: true,
+      title: true,
+      status: true,
+      scheduledFor: true,
+      customer: { select: { name: true, suburb: true } },
+    },
+  })
+}
--- a/app/api/jobs/[jobId]/route.ts
+++ b/app/api/jobs/[jobId]/route.ts
@@ -1,23 +1,22 @@
-import { getViewer } from '@/lib/dal'
-import { prisma } from '@/lib/prisma'
+import { getJobForViewer, getViewer } from '@/lib/dal'
 
 export async function GET(
   _request: Request,
   { params }: { params: Promise<{ jobId: string }> },
 ) {
   const viewer = await getViewer()
   if (!viewer) {
     return Response.json({ error: 'Not signed in' }, { status: 401 })
   }
 
   const { jobId } = await params
-  const job = await prisma.job.findUnique({
-    where: { id: jobId },
-    include: { customer: true },
-  })
+  const job = await getJobForViewer(viewer, jobId)
+
+  // A job in another organisation gets the same 404 as a job that does
+  // not exist, so the response does not reveal which ids are real.
   if (!job) {
     return Response.json({ error: 'Not found' }, { status: 404 })
   }
 
   return Response.json(job)
 }
```

The regression test replaces the test that came with the pull request:

```ts
// tests/access/job-route.spec.ts
import { test, expect } from '@playwright/test'

// The test database is seeded with one job in each organisation. The saved
// sign-in state holds a live session cookie, so playwright/.auth is listed
// in .gitignore. baseURL is set in playwright.config.ts.
const ORG_A_JOB_ID = 'seed-job-org-a'
const ORG_B_JOB_ID = 'seed-job-org-b'

test.describe('GET /api/jobs/[jobId] as an Org B crew member', () => {
  test.use({ storageState: 'playwright/.auth/crew-org-b.json' })

  test('reads a job in its own organisation', async ({ page }) => {
    const response = await page.request.get('/api/jobs/' + ORG_B_JOB_ID)
    expect(response.status()).toBe(200)
  })

  test('gets 404 for a job in another organisation', async ({ page }) => {
    const response = await page.request.get('/api/jobs/' + ORG_A_JOB_ID)
    expect(response.status()).toBe(404)
    expect(await response.text()).not.toContain(ORG_A_JOB_ID)
  })
})

test.describe('GET /api/jobs/[jobId] when signed out', () => {
  test.use({ storageState: { cookies: [], origins: [] } })

  test('gets 401', async ({ page }) => {
    const response = await page.request.get('/api/jobs/' + ORG_B_JOB_ID)
    expect(response.status()).toBe(401)
  })
})
```

Why this test holds the fix in place:
- page.request uses the same cookie jar as the page's browser context, so each request carries the session saved for that test group.
- On commit 7d41c2e the second test fails, because the response is 200. On the fix commit all three pass.
- If a later change reads jobs outside getJobForViewer, or drops the organisation condition, the second test fails in CI before the change ships.
- The first test keeps the fix honest: a route that refused everyone would fail it.
- OWASP Top 10:2025 asks developers and QA staff to include functional access control in their unit and integration tests. This is one such test. Write it, or read it line by line, yourself: OWASP's Secure Coding with AI Cheat Sheet warns against trusting tests generated by the same agent that wrote the code as evidence of security.


## Review checklist

Copy this into your pull request template. Tick an item only when you have read the code that answers it.

Authorisation on every data path
[ ] List every entry point the change adds or touches: each exported method in a route file, each Server Action, pages that query data, webhooks, background jobs, exports and search.
[ ] For each one, find where the caller is identified and where the query is limited to that caller's records or organisation. Both happen on the server, in the same code path as the read or write.
[ ] Organisation, role and ownership values come from the server-side session or the database, never from the path, query string, body or a header.
[ ] Database clients are imported only inside the data access layer. Read any route, action or page that imports one directly first.
[ ] A record that belongs to another user or organisation gets the same response as a record that does not exist.
[ ] Lists, exports, search and counts apply the same organisation filter as the single-record read.

Secret handling
[ ] No key, token, password or connection string is added to source, tests, fixtures, seed data or config, in the final files or in any commit on the branch.
[ ] Each new public environment variable (NEXT_PUBLIC_ in Next.js) holds only a value you are content for every visitor to read.
[ ] Modules that read secrets import server-only, and only the data access layer reads process.env.
[ ] Errors sent to the caller are generic, with no stack traces, queries, keys or tokens.
[ ] Saved test sessions and fixture credentials are kept out of the repository.

Untrusted input
[ ] Dynamic route segments, query strings, headers, cookies, form fields and JSON bodies are validated on the server before use.
[ ] Create and update handlers name the fields they accept. No request body is passed whole to the database.
[ ] Queries go through the ORM or parameterised queries, and any raw SQL assembled from strings is flagged.
[ ] HTML that users can submit passes through a maintained sanitising library before it is rendered.

Dependencies and the build
[ ] Every added package exists on the public registry under exactly the name intended, from the publisher you expected.
[ ] New and changed versions are checked against the GitHub Advisory Database, NVD or OSV.
[ ] Lockfile changes match the manifest changes, including any transitive packages pulled in.
[ ] Install and build hooks (preinstall, postinstall, prepare, prebuild), CI workflow files and Dockerfiles in the diff are read line by line.

Assumptions in AI-written code
[ ] Each claim in the pull request description is checked against the code rather than taken as given.
[ ] Every file in the change is read, including files the description does not mention.
[ ] The tests include refusal cases: another user's record, another organisation's record and a signed-out request.
[ ] No test was deleted, skipped or loosened in the same change, and no assertion was rewritten to expect the current behaviour.
[ ] Permission helpers do real work: none returns true unconditionally, and no check is left commented out.
[ ] Framework calls match the version in the lockfile, such as awaiting params in route handlers from Next.js 15 onwards.

Where static analysis tools fit

Many teams already run a static analysis (SAST) tool in their pipeline, and it is worth keeping.

OWASP's page on source code analysis tools lists what such tools do well: they scale, can run repeatedly in nightly builds or continuous integration, identify certain well-known flaws such as SQL injection, and point developers to the file and line. It lists their limits as plainly.

Many vulnerability types are difficult to find automatically, including authentication problems, access control issues and insecure use of cryptography. False positives are numerous, and it is difficult to prove that a reported issue is a real vulnerability.

Those limits mark out where a review earns its place. A rule can match a raw SQL string. A query that filters by id alone looks like correct code, because the flaw is a condition that is not there.

Send your current tool results with the scope, so warnings your team has already triaged are not reported back to you as new. The SAST versus DAST comparison explains how static and dynamic testing divide the work.

What to have ready before the review starts

Most of what a code review needs can be gathered while the scope is being agreed.

  • Read-only access to each repository in scope, and the branch or commit to review. Revoke it once the retest is complete.
  • The scope itself: the directories, routes or modules to read, or the pull requests and branches that make up the change.
  • A short note of who may see and change what: the roles, whether customers belong to separate organisations, and any record that is meant to be shared. The review checks the code against the rules you state.
  • The lockfile, the framework and ORM configuration, and the names of the environment variables each deployment uses. Names are enough to review how the code handles them; the values are not needed.
  • For confirmation on a running build: a staging environment deployed from the same commit, written authorisation for that target, two test accounts for each role, and accounts in two separate customer organisations if the application serves more than one.
  • Static analysis results, dependency alerts and earlier reports, so known issues are recognised as known.
  • A technical contact who can answer questions about the code and pause testing on the staging build if anything looks wrong.

What the report records, and how the retest works

The report is written for two readers: the developer who will fix each finding, and the person deciding what gets fixed first.

The sample report on the penetration test report example page, built from a lab application, shows the format.

  • The scope as reviewed: each repository, the commit read, the areas covered and the areas left out.
  • For each finding, the file, line and commit, a code excerpt with any secret redacted, and its label: confirmed on the running build, with the request and response, or code only, with the reason.
  • Two ratings for each rated finding: a CVSS v3.1 score with its vector string, and a business-risk rating that weighs the data involved, how exposed the code path is, the controls around it and the cost of disruption.
  • The OWASP Top 10:2025 category and the ASVS 5.0 requirements each finding was reviewed against. That records what was checked. It is not a compliance claim, and OWASP does not certify software.
  • A fix written for your codebase, and retest criteria that say what the retest will check, written so your developers can turn them into regression tests.
  • Areas read with no finding, recorded for the commit reviewed rather than as proof that the area is sound.

The retest

One consolidated retest is included. You request it within the window set in your statement of work, once the fixes are deployed to an identified build of the same application. It covers the reported findings within the agreed scope: the changed code is read again at the new commit and, for findings confirmed on the running build, the original requests are repeated.

New features and unrelated changes are scoped separately. Each finding is then marked fixed, partially fixed, still reproducible or not retested, and a finding that was not retested is reported as such rather than as passed.

Your code and the evidence

Access is read-only, so the review changes nothing in your repository. Code excerpts in the report are evidence and are handled like any other evidence: secrets redacted, stored encrypted in Australia, deleted on the schedule set in the data handling terms, and processed outside Australia only where your statement of work approves it.

You choose who makes the fixes: your own developers, your agency, or a Clever Ops security fix sprint under a separate statement of work.

When a code review is the wrong place to start

A code review answers questions about code.

Some questions need a different kind of work, and it is better to say so before the scope is signed.

  • A customer, insurer or questionnaire asked for a penetration test. A code review on its own does not answer that request. A web application and API penetration test with code access added covers both.
  • The app was made with an AI builder on Supabase or Firebase and nobody on the team reads its code. The vibe-coded app security check is the better first step: it tests the database rules and keys directly and reports in plain English.
  • A tender, panel or contract requires a CREST-accredited provider. Clever Ops is not CREST accredited, so we refer that work to a provider that is.
  • The code is a Laravel application or a mobile app. Both sit outside this service.
  • You suspect the application has already been compromised. Call an incident response specialist first; a review can follow once the incident is contained.
  • The application is very logic-heavy, such as a marketplace, a lending platform or a multi-tenant product with complex billing. These are scoped individually, or referred when a larger firm is the better fit.
  • You need a certificate. A review report is evidence for a decision a customer or auditor makes, not a certification of the code.

Frequently asked questions

A secure code review reads the source to find flaws, including in paths no screen calls. A penetration test sends requests to the running application as each role and records what can actually be reached on the configuration that is deployed. Each covers ground the other misses. Clever Ops confirms code findings against a running build where the scope allows, and a web application test can add code access when the riskiest logic sits in a few files.

No. Access is read-only and limited to the repositories in scope, and the scope names the areas or changes to be read. Some context outside those areas helps, such as the shared authorisation helpers and the database schema, because a route can only be judged against the checks it calls. Revoke the access once the retest is complete.

Yes. The review is the same, with extra attention on what the tool may have assumed: that a route is only reached from a filtered screen, that signing in is enough, that its own tests prove the change, and that every package it chose exists and is current. Findings in AI-written code are evidenced, rated and retested like any other.

No. A static analysis tool matches patterns across a codebase and is good at scale and at certain well-known flaws. OWASP lists access control issues, authentication problems and insecure use of cryptography among the flaws such tools find difficult to detect automatically, and notes numerous false positives. Keep the tool in your pipeline and send its results with the scope.

No. Access is read-only, and fixes come back as written guidance with retest criteria. Your developers or your agency make the changes, or a Clever Ops security fix sprint can, under its own statement of work.

It shows which ASVS 5.0 requirements were reviewed and what was found against each. OWASP does not certify software, and it describes the Top 10 as an awareness document that is a bare minimum when used as a standard for secure code review. If a customer asks, give them the scope and findings and let them weigh those against their own requirement.

Clever Ops quotes each review after a scoping call rather than publishing prices. The effort follows the scope: how many routes and modules are read, how many roles and customer organisations the code has to keep apart, and whether a running build is in scope for confirming findings. The penetration testing cost guide explains how scope drives effort across this kind of work.

Scope the right test for your application

Tell us what you have built, who uses it and when it needs to launch. You will get a plain-English recommendation: a website audit, a web application test or a referral to a specialist.