AI app security audit — RLS, secrets, OWASP, in 3 days.

What we look at — the AI-generated code vulnerability pass

The 3-day audit is structured around the seven failure classes that account for almost every AI-built app incident we have triaged. The order matters because a finding higher in the list usually invalidates findings lower in the list — there is no point reviewing rate limits on an endpoint that already returns every other tenant’s data.

Row-level security on every Supabase table. We log into a fresh incognito window as a synthetic user, capture a session, and walk through every table the application reads or writes. For each table we ask three questions: can an unauthenticated visitor read this, can a different authenticated user read this, and can the user mutate it through the anon key. Anything that should be protected and is not goes into the report as Critical. Lovable apps almost always have at least one Critical finding here; the public incident pattern documented by The Register in February 2026 is exactly this failure expressed at scale.

Secrets in repository history, environment files, and frontend bundles. Gitleaks scans the entire commit history for keys, tokens, and credentials. Webpack/Vite bundle analysis confirms that no service-role keys, Stripe secret keys, or third-party API tokens have leaked into the client bundle. The frontend-bundle check catches the most common Lovable mistake, which is pasting a Supabase service-role key into a client component instead of using the anon key with RLS.

Authentication logic and session handling. We exercise sign-up, sign-in, sign-out, password reset, email verification, and social login. We test session refresh on a stale token. We test the post-OAuth callback against a redirect URL that is not in the allow list. We test what happens when a user changes their email. Each of these is a path that AI generators ship with a happy-path implementation and a missing edge case.

OWASP top-ten for web applications. Injection, cross-site scripting, cross-site request forgery, broken access control, server-side request forgery, insecure deserialization, security misconfiguration, vulnerable components, identification failures, and insufficient logging. Some of this is automated (Semgrep rule packs, npm audit on the lockfile, Snyk on the container if there is one); the rest is manual. Industry benchmarks — see our 2026 vibe-coding research — show roughly half of AI-generated code shipping with known vulnerabilities; that’s the floor we expect to clear, not the ceiling.

CORS, rate limiting, and input validation on every public API route. We enumerate every endpoint that does not require authentication and confirm each has a rate limit, an origin allow-list, and a schema that validates the payload. AI generators routinely ship endpoints with permissive CORS (access-control-allow-origin: *) and no rate limiting at all, which becomes an abuse vector the day a bot finds it.

Webhook signature verification and idempotency.Every Stripe, Slack, GitHub, or other webhook endpoint must verify the provider’s signature header and must be idempotent against a replay of the same event ID. AI generators routinely ship the happy-path handler and forget the signature check, which means anyone on the internet can POST a fake event and trigger a billing state change. We verify both properties on every webhook the application accepts.

Deploy and infrastructure configuration. Environment variables in the production host versus the repo, security headers (Content-Security-Policy, Strict-Transport-Security, X-Frame-Options), TLS configuration on the custom domain, and the database backup posture. We confirm that a restore from backup has been tested at least once.

What you receive at the end

A PDF report with an executive summary, a finding-by-finding breakdown with severity ratings using the standard Critical / High / Medium / Low taxonomy, reproduction steps for each Critical and High, and a patch diff ready to merge for each. Every finding maps to a specific OWASP, CWE, or vendor guideline so the report is suitable for sharing with investors, acquirers, or compliance reviewers without translation. We include a 30-minute Loom walkthrough so the founder hears the reasoning behind the severities, not just the labels.

The patch diffs are intentionally minimal. We do not refactor adjacent code while we are in the file, and we do not change anything outside the scope of the finding. That keeps the audit useful even if you want to merge the patches over several weeks rather than all at once. Each diff is independently reviewable and independently revertible, which matters when the audit lands on a Friday and the team wants to ship Critical fixes before Monday and defer Mediums.

When this audit alone is not enough

If we find more than six Critical and High findings combined, we will recommend upgrading to Break-the-Fix-Loop ($3,999) which bundles the audit plus full remediation including Mediums and Lows. If the application is in a regulated industry (HIPAA, PCI, SOC 2) the $499 audit gives you the technical baseline but it is not a substitute for an accredited assessor — we say so explicitly in the report and point you at the right next step. The audit is calibrated for AI-built SaaS apps under 10,000 lines pre-launch or in early traction.