Check your own app — free, in about a minute.
Several checks on this list are ones the mini-scan runs automatically against your live Lovable app — open Supabase/Firebase rules visible in your shipped config, exposed files, headers, leaked keys. Start there before you work the rest by hand. No account, no card.
Run the free mini-scan →Your Lovable app is done — it builds, it demos, and you're ready to put it in front of real users. Run this checklist first. Each item is one concrete check with one verification step, organized so you can work through it in an afternoon. Items marked [Critical] are the ones that cause real incidents in Lovable apps.
[Critical] 1. RLS is enabled on every table. In Supabase → Table Editor, open each table and confirm the RLS badge is on. Lookup tables, join tables, "internal" tables — all of them.
[Critical] 2. No policy allows anonymous writes. Read every policy in Supabase → Authentication → Policies. Delete any USING (true) or WITH CHECK (true) on INSERT, UPDATE, or DELETE. A policy that is true for everyone is the same as no policy.
[Critical] 3. Policies scope data to the owner. The pattern you want for user-owned data is auth.uid() = owner_id on both USING and WITH CHECK. Read each policy out loud and ask: "Could a stranger who signed up for a free account abuse this?"
[Critical] 4. Test RLS with two throwaway accounts. Sign in as Account A and create a row. Sign in as Account B and try to read, update, and delete Account A's row through the REST API with curl. All three must fail. If any succeeds, your policy has a hole.
5. Storage buckets have policies too. For each bucket in Supabase → Storage, decide whether it must be public. User uploads belong in private buckets with storage.objects policies scoping access to the owner. Test: upload as Account A, try to download as Account B — it must fail.
[Critical] 6. The service role key exists in exactly one kind of place: server-side. Run this from your repo root:
grep -ri "service_role" . --include="*.ts" --include="*.tsx" --include="*.js" --include="*.json"
git log -p -S "service_role" | head -60
The service role key bypasses every RLS policy you just wrote. Acceptable: Supabase Edge Functions, your backend server, deployment environment variables. Unacceptable: frontend code, committed .env files, Lovable's client-side config. If it ever appeared anywhere unacceptable, rotate it in Supabase → Settings → API now.
7. No other secret is in the frontend bundle. Any key referenced from frontend code gets baked into the shipped JavaScript at build time — the browser needs the literal value, so it becomes public. Download your production JS bundle and grep for sk_live, sk-, AIza, api_key, secret. If a real key shows up, rotate it and move the call server-side.
8. Nothing secret was ever committed to git. Check history, not just the current tree — deleted secrets stay compromised:
git log -p -- .env .env.local | grep -iE 'key|secret|token|password' | head
Anything found gets rotated. Removing the file isn't enough.
[Critical] 9. Every Edge Function that does anything privileged verifies the caller's JWT first. Open each function and check the first lines. If it writes data, sends email, touches payments, or calls a third-party API without verifying the Authorization header against supabase.auth.getUser(), it's a public endpoint.
10. Prove it from the outside. Call each function with no Authorization header and confirm you get 401, not results. Frontend route guards (if (!user) redirect) are cosmetic — the check must live on the server.
11. Auth errors are uniform. Trigger a login failure with a wrong password and with a nonexistent email. Both should return the same generic message — "Invalid email or password" — never one that reveals whether the account exists.
12. Password and auth pages aren't cacheable. Login and signup pages should send Cache-Control: no-store. Shared computers and corporate proxies cache what you let them.
13. HTTPS everywhere, enforced. curl -sI http://yourdomain.com must 301 to the HTTPS version — not serve content over plain HTTP. Lovable's default hosting handles this; your custom domain setup might not.
[Critical] 14. The security headers are present. Run:
curl -sI https://yourdomain.com | grep -iE 'strict-transport-security|content-security-policy|x-content-type-options|x-frame-options'
You want: Strict-Transport-Security with a long max-age, a Content-Security-Policy (start reasonable, tighten later), X-Content-Type-Options: nosniff, and clickjacking protection via X-Frame-Options or CSP frame-ancestors. Lovable won't set these for you — add them at your hosting layer or edge.
15. /.env and /.git don't resolve. These are the two paths automated scanners probe first:
for p in /.env /.git/HEAD /debug /admin /api/debug; do
echo "$p -> $(curl -s -o /dev/null -w '%{http_code}' https://yourdomain.com$p)"
done
Anything returning 200 on a path that shouldn't exist is a fix-it-now item.
16. CORS is restricted. If your API serves only your own frontend, Access-Control-Allow-Origin should name your domains — not *. A wildcard on credentialed endpoints is an open door.
17. Error messages are generic in production. Trigger failures on purpose — bad IDs, malformed JSON, unauthorized requests — and confirm users see friendly messages, not stack traces or Supabase error detail.
18. No debug scaffolding is live. Delete /debug, /test, seed scripts, and sample-data routes before deploying. An unlinked URL is not access control.
19. Dependencies are audited. Run npm audit and fix every critical before launch. Turn on Dependabot or Renovate so it stays fixed.
20. Uploads are validated by content, not extension. Check MIME type from file content, cap file size, and never serve uploads from a path that could execute them.
21. Rate limiting exists on auth endpoints. Lovable doesn't ship rate limiting — your login, signup, and password-reset endpoints are unthrottled by default. Put Cloudflare (or your edge) rate-limit rules in front of them, then re-test: 50 rapid login attempts should start returning 429s.
22. Backups are confirmed and tested. Verify your database plan includes point-in-time recovery, and actually restore to a staging project once before you need it for real.
23. There is security logging and a security contact. At minimum, log sign-ins, failed sign-ins, password changes, and admin actions somewhere you review. Add a security@yourdomain.com contact (a /.well-known/security.txt file works) so researchers report issues to you instead of posting them.
24. Re-run this checklist after every significant AI-assisted change. A "quick cleanup" refactor is exactly how an auth check silently disappears. Vibe-coded apps evolve fast — verify at the speed you ship.
Twenty-four checks is a real afternoon — and the check you skip is the one that matters. PreShipIt probes your app the way an attacker would: from the outside, with no login and no access to your source code. Paste your URL, attest that you own the app, and for $29 (one time) you get a plain-English prioritized report of what's actually exposed.
PreShipIt runs an outside-in, unauthenticated scan of the single host you submit. It doesn't test anything behind a login, doesn't review your source code, and doesn't guarantee your app is secure — it shows you what an unauthenticated visitor can see and reach, so you can fix it first.
Get your pre-ship inspection at preshipit.com
The PreShipIt Brief — a short weekly email for people shipping vibe-coded apps: the week's important vulnerabilities and launch-safety checks, in plain English.
New and free. Double opt-in: we email you a confirmation link before anything else arrives. Unsubscribe any time.
Check your own app — free, in about a minute.
Several checks on this list are ones the mini-scan runs automatically against your live Lovable app — open Supabase/Firebase rules visible in your shipped config, exposed files, headers, leaked keys. Start there before you work the rest by hand. No account, no card.
Run the free mini-scan →← Back home · Run a free mini-scan · Scan my app — $29 · See a sample report