Free launch audit — a senior engineer reads your repo and tells you exactly what's blocking launch.Claim yours

Free launch audit

Find out what's between your AI-built app and a real launch

A senior engineer reads your repo — Lovable, Bolt, v0, Cursor, Replit, Claude Code, or hand-written — and sends back a ranked, plain-English report within 48 hours. Free, no card, and the list is yours whether or not you hire us.

In short

The Gen2Prod launch audit is a free, senior-engineer review of an AI-generated codebase. Within 48 hours of a fifteen-minute call you receive a written report that rates every finding by consequence — data exposure first, then anything that costs money, then performance, reliability, release hygiene and maintainability — with each one reproduced so you can verify it, and a fixed price against each fix. There is no card, no contract and no obligation; the report is written to be handed to any developer, or acted on yourself.

Price
Free — no card, no contract
Turnaround
Written report within 48 hours of the call
Who reads it
A senior engineer who has shipped and run production systems — never a junior, never only a scanner
Access needed
A read-only repo link; NDA signed first on request
What you keep
The full report and the price list, whether you hire us or not

What the audit checks

Grouped the way the report is, and ordered by consequence: what could expose data comes first, what could lose you a customer comes last.

1

Data exposure

  • Supabase Row Level Security: off, permissive, or missing on a table
  • Secrets in the client bundle, `VITE_`/`NEXT_PUBLIC_` variables, or the git history
  • Authorisation enforced only in the UI, with the server trusting the caller
  • Server Actions, edge functions and API routes without a session check
  • Input validation and rate limits on anything that costs money or sends mail
2

Data integrity

  • Schema shape: relations, constraints, and where the same fact lives twice
  • Missing indexes on the columns your queries actually filter by
  • N+1 patterns and per-render fetching
  • Migrations: versioned and reversible, or pushed and forgotten
  • Backups, and whether anyone has ever restored one
3

Performance

  • Largest Contentful Paint on a real device with real data, not the demo dataset
  • Bundle size and what's in it that shouldn't be
  • Request waterfalls: what the page waits on before it can paint
  • Caching: what's cached, what could be, what's cached wrongly
4

Reliability

  • Error handling: what is caught, what is swallowed, what reaches the user as a blank screen
  • Error tracking, uptime checks and alerts — whether anyone is told when it breaks
  • Logs you could actually debug from
5

Release hygiene

  • How a change gets to production, and whether tests run on the way
  • Environment variables per environment, and what differs between preview and production
  • Rollback: is there a way back, and has it been tried
  • Domains, TLS, headers and the things that break silently after launch
6

Maintainability

  • Files and components too large to change safely
  • Duplicated logic and abandoned experiments
  • Types: real, or `any` wherever the compiler objected
  • Tests: what they'd catch, not just whether they pass
  • Whether the next developer — human or AI — could find their way around

How it runs

  1. 1

    Fifteen minutes on a call

    What you built, what it's for, who's using it, and where you're stuck. You share a read-only repo link at the end, or after an NDA if you'd rather.

  2. 2

    A senior engineer reads the repo

    Not a scanner and not a junior. Static analysis finds the obvious; the rest — an authorisation decision made in the wrong place, a test that can't fail — takes someone who has run production systems.

  3. 3

    The report lands within 48 hours

    Ranked by consequence, every finding reproduced, a price against each fix. If we can't find three problems worth fixing, the report says so and we send you on your way.

What you get back

  • A launch-readiness score, in plain English, with the three things that most need fixing named first
  • Every finding rated by consequence and reproduced, so you can verify it yourself
  • A fixed price and a timeline against each fix, so you can choose one, several or none
  • The report as a document you can hand to any developer
  • An optional fifteen-minute walkthrough of the findings
Get my free audit

Rather not book a call? Email a read-only repo link to [email protected].

The audit — questions we get asked

Is the audit really free?

Yes. No card, no contract, no obligation, and no 'free audit' that turns out to be a sales call with a PDF attached. A senior engineer reads your actual repository and writes a real report. The commercial logic is simple: about half of the people who read the report hire us for at least one fix, and that's enough.

What access do you need?

A read-only link to the repository is enough to start; we can sign an NDA before you share it. We don't need production credentials or database access for the audit — the report is about the code and the configuration. You control access throughout and can revoke it any time.

How is this different from an automated security scan?

A scanner finds the patterns it has signatures for — a leaked key, a known-vulnerable dependency. It can't tell that an authorisation check is in the UI rather than the API, that a test passes because it mocks the code it tests, or that your schema will fall over at ten thousand rows. We run the scanners too; the value is in the reading.

What if my app is actually fine?

Then the report says so, and you've spent fifteen minutes to learn it. It happens, particularly with codebases where a developer has already been through. We'd rather tell you that than invent work.

Do I have to hire you afterwards?

No. The report is written to be acted on by anyone: every finding is reproduced and every fix is described. Fix them yourself, hand the list to your developer, or take us up on one of the prices. The list is yours either way.

Your AI-built product deserves a real launch.

Start with the free audit. In 48 hours you'll know what's broken, what each fix costs, and whether it's even worth doing — before you've spent a dollar.

Free audit, no card · Fixed price before we start · Your code stays yours