Skip to content
All services

AI App Audit & Hardening

You built it with AI. Get it audited before real users arrive.

Lovable, Bolt, Cursor, Claude Code and Codex get a Next.js and Supabase app working fast. I read the code underneath it and tell you what to fix first, for a fixed price.

An app built with AI coding tools is usually solid in the interface and thin underneath: Supabase policies left open, role checks done only in the browser, secrets in the client bundle, webhooks nothing verifies. A fixed-price audit reads the code and returns a written fix list ordered by risk. The fixes are a separate decision, yours to make after you've read it.

Where these apps leak

An AI coding tool writes what you asked for. It has no stake in what happens on the day a stranger reads your network tab. Four gaps account for most of what I find:

  • The database trusts everyone

    Row Level Security is off, or the policies allow everything. Any logged-in user can read another tenant's rows straight from the Supabase client, and the app looks perfectly normal while it happens.

  • The checks live in the interface

    The admin button is hidden for normal users, so the admin action feels protected. The route behind it never asks who is calling, and a browser console is all it takes to find out.

  • Keys ship to the browser

    A service role key or a third-party secret ends up in a client component, a public env var, or committed to the repo. It works in development, and it is readable by anyone once deployed.

  • Nothing verifies the callback

    Webhooks are accepted without checking the signature, and a retry runs the same job twice. Both are invisible until the day a payment or a job queue depends on them.

What the audit checks

The same pass every time, so the report is comparable and nothing gets skipped because the app looked fine.

  • Supabase Row Level Security per table, and whether tenant data can cross between accounts
  • Auth and role checks enforced server-side in route handlers and server actions, not only in the UI
  • Secrets and environment variables: what is public, what is committed, what reaches the client bundle
  • Webhook endpoints: signature verification, replay handling, and what happens on an unsigned request
  • Background jobs: idempotency keys, retry behaviour, and the jobs that silently fail twice
  • Error handling and logging: what the user sees, what you can debug later, what leaks in a stack trace
  • Performance and Core Web Vitals: render strategy, data fetching, bundle weight, image handling
  • Vercel deployment: environment separation, caching and revalidation, build and runtime configuration

Two ways to work

The audit is the whole first engagement. Whether I touch the code afterwards is a decision you make with the report in hand.

  • Fixed price

    The audit

    A full read of the codebase and a written report with a prioritised fix list. One price, agreed before I start, with no dependency on what I find. You can act on it yourself, give it to your team, or show it to an investor doing technical due diligence.

    • Everything in the checklist above
    • Findings ranked by risk, with the effort each fix takes
    • Read-only repo access, no production credentials
    • Yours to keep, whoever does the work
  • Quoted from the report

    The fixes

    Optional, and decided after you've read the findings. I work down the list in priority order, on a branch, with each fix reviewable on its own. You choose where to stop, and nothing gets bundled in that the report didn't justify.

    • Priority order, one reviewable change at a time
    • Scoped to findings, not a rewrite
    • Stop whenever the remaining risk is acceptable
    • Ongoing care plan afterwards if you want one

How it runs

Four steps, and you can stop after the third with something useful in your hands.

  1. Read-only repo access

    You add me to the repository as a reader and point me at the Supabase project's schema. That is enough for the audit. I don't need production credentials, and I don't make a single commit at this stage.

  2. Read the code

    I go through the app the way an attacker and a load spike would: the policies, the server boundaries, the secrets, the webhooks, the jobs, the deployment config. Not a linter run; a senior read of what the generated code actually does.

  3. The written report

    A document in plain language, one entry per finding: what it is, what it lets someone do, where it lives in the code, and how much work the fix is. Ordered worst risk first, so the top of the list is also your sprint plan.

  4. Fixes, if you want them

    The audit stands on its own and the list is yours to hand to anyone. If you'd rather I do the work, the fixes are quoted from the report, and you can take the top three and stop there.

Who is reading your code

Ten years and more than 300 projects, for clients from PepsiCo and Ooredoo to the European Union. Top Rated on Upwork, member since 2016. The judgement about what is worth fixing comes from having maintained the decisions, not from reading about them.

The stack is the one I ship in. Fennec360 started as a WordPress site and moved to a custom Next.js build as the business scaled, with payments and a student platform behind it. Hsabet runs 70 calculators on Next.js with 563 automated tests on the logic. This site is Next.js on Vercel, and the work on it is in the open.

No developer involved at all, or one who vanished mid-build? That version of the problem is its own service here: website rescue and takeover.

For a code review or architecture advice outside security, book technical consulting by the hour.

Questions founders ask first

Do you rewrite the app?

No. The audit comes first, and most AI-built apps don't need a rewrite: the structure is usually fine and the gaps are in the parts the tool couldn't reason about, like policies, server-side checks and webhook handling. I fix what matters and leave the rest alone. If a rewrite genuinely is the cheaper path, I'll show you the evidence from the audit before anyone commits to it.

Which stacks do you audit?

Next.js and React on the front, Supabase or Postgres behind it, deployed on Vercel. That's the stack most AI coding tools generate, and it's the stack I ship production work in. Node APIs, Stripe and other webhook providers, and background job queues come with the territory. If your app is on something else entirely, send it over and I'll tell you honestly whether I'm the right person.

Do I need to give you production access?

No. Read-only access to the repository is enough for the audit, plus the database schema and the names of your environment variables, never their values. If you later want me to fix things, we can still work on a branch and a staging environment. Production credentials are a separate conversation you're free never to have.

How long does an audit take?

It depends on the size of the codebase, so I quote the price and the turnaround after a look at the repo rather than guessing from a form. I reply within 24 hours, and if the app is already live with real users, say so and it moves to the front of the queue.

Will you tell me the AI-built code is bad?

No, and that isn't the useful part. These tools produce a lot of reasonable code, and you got to a working product faster than a traditional build would have. The report is about what's exposed and what it would cost to close, with no commentary on how the app got here.

What if I built it with no coding background at all?

That's a common starting point and it changes nothing about the work. The report is written so a non-developer can act on it: what the risk is in plain terms, and what has to change. I've spent ten years explaining technical decisions to founders and marketing teams, and that part of the job is the same here.

Send me the repo. I'll tell you what I'd fix first.

Tell me what you're working on and I'll get back to you within 24 hours.