Check your own app — free, in about a minute.
The free mini-scan checks your live homepage for TLS/HTTPS basics, response security headers, cookie flags, exposed sensitive files, Firebase/Supabase backend rules, and the WordPress plugin versions your site exposes. You get a score and the finding titles — no account, no card.
Run the free mini-scan →"Which AI app builder is the most secure?" is the wrong question — but it's the question everyone asks, so let's answer it honestly: none of them ships secure apps by default, and the differences that matter are about what each one makes easy to get wrong. The platform handles the infrastructure; the application layer is yours on all four.
This comparison doesn't rank the builders — it maps, for each one, where secrets tend to leak, what the default data access looks like, and what you must personally verify before shipping. No invented data: these are the checkable patterns in how each stack is typically built.
Every AI builder optimizes for the same thing: a working demo, fast. Working means data flows; fast means nothing slows it down for safety. So on every platform, the AI will wire up databases without access policies, build API endpoints without auth checks, paste keys wherever they make the build pass, and leave debug scaffolding in place. The security posture of your app is determined by the verification pass you run afterward — not by which builder you chose. Pick your builder for product reasons. Then check the things below.
Typical stack: React frontend, Supabase for database/auth/storage, Edge Functions for server logic.
Where secrets leak: The Supabase service role key — it bypasses every database policy, and the AI sometimes references it from frontend code or leaves it in client config. The public anon key is supposed to be in the frontend; it only becomes dangerous when Row Level Security is off.
The default-data-access problem: Supabase tables the AI creates frequently ship with Row Level Security disabled or with permissive policies (USING (true)). With RLS off, the public anon key reads and writes everything.
What to check:
- RLS enabled on every table, policies scoped to auth.uid()
- service_role key exists only in Edge Functions / server env — grep the repo and git history
- Every Edge Function doing anything privileged verifies the caller's JWT first (curl it logged-out; expect 401)
- Storage buckets: public only when the contents are truly public, with storage policies on private buckets
Platform handles: TLS on *.lovable.app, managed Postgres, auth primitives. You handle: RLS policies, function auth, headers, rate limiting.
Typical stack: Varies — React + Vite with server functions, full Next.js, or Bolt frontend wired to Supabase. The variety is itself the risk: there's no single blessed pattern for the AI to follow.
Where secrets leak: The shipped JS bundle. Bolt's most common incident pattern is a key referenced from frontend code and baked into the production bundle at build time — Stripe secret keys, OpenAI keys, database credentials, all readable via DevTools. Second most common: .env files committed when exporting to GitHub.
The default-data-access problem: API routes and server functions the AI scaffolds typically have no authentication checks. Frontend route guards look like protection but aren't — the API answers curl the same as it answers your app.
What to check:
- Download the production JS bundle and grep for key patterns (sk_live, sk-, AIza, service_role, secret)
- git log -p for any secret ever committed — rotate what you find, don't just delete it
- Logged-out curl of every API route your app uses — expect 401/403, not data
- /.env probe on the deployed URL — expect 404
- If Supabase is the backend: same RLS verification as Lovable above
Platform handles: Build and deploy pipeline, preview URLs. You handle: everything application-layer — secret placement, API auth, headers, rate limiting.
Typical stack: Next.js App Router (Server Components, Route Handlers, Server Actions) deployed to Vercel, usually with Postgres (Neon/Supabase).
Where secrets leak: NEXT_PUBLIC_ variables. Next.js embeds any NEXT_PUBLIC_-prefixed env var into the client bundle by design, and v0-generated code sometimes reaches for that prefix to make values available in components. If the value is a secret, it's public. Also: database connection strings committed to the repo during iteration.
The default-data-access problem: Route handlers and Server Actions without auth checks, plus Server Components that over-fetch (fetching full records, passing them as props, and thereby serializing internal fields into the HTML).
What to check:
- Audit every NEXT_PUBLIC_ variable — publishable keys and IDs only, never secrets
- Logged-out curl of every /api route — expect 401/403
- View source on pages and search the initial HTML for fields that shouldn't be there (other users' emails, internal flags, tokens)
- Auth wired on the server (middleware/server components), session cookies with HttpOnly/Secure/SameSite
- Security headers via next.config.js headers() — Vercel doesn't set them for you
- Preview deployments: confirm they don't expose production data to anyone with the link
Platform handles: TLS with auto-renewal, HTTP→HTTPS behavior, edge network, DDoS absorption — the strongest infrastructure defaults of the four. You handle: route auth, secret scoping, headers, over-fetching.
Typical stack: Whatever Agent built — often Node/Python with Replit's Postgres, served from the repl and deployed via Replit Deployments.
Where secrets leak: Hardcoded keys and .env files. Agent frequently skips the Secrets tool and writes keys directly into code or .env files — which then ride along when you connect GitHub. Console output in the repl history is another place keys end up.
The default-data-access problem: Endpoints without auth (same as Bolt), plus the database's own access configuration — verify it requires a strong password over TLS rather than trusting the network. Also verify repl visibility settings: if the workspace is viewable, your source (and its mistakes) is readable.
What to check:
- Repl visibility setting — who can see the code?
- Project-wide grep for key patterns, plus git history if GitHub is connected
- Logged-out sweep of every endpoint, including /admin, /debug, and Agent scaffolding
- Database: strong unique password, TLS required, connection string in Secrets only
- Production deployment URL vs. dev URL — ship the deployment, with HTTPS enforced and headers set
- Rate limiting on auth endpoints (Agent never adds it)
Platform handles: Hosting, deployment pipeline, managed database offering. You handle: secret placement, endpoint auth, headers, rate limiting, workspace visibility.
| Lovable | Bolt.new | v0 / Vercel | Replit Agent | |
|---|---|---|---|---|
| Most common secret leak | Service role key in frontend | Keys baked into JS bundle | NEXT_PUBLIC_ secrets |
Hardcoded keys / .env in git |
| Default data access risk | RLS off or permissive | API routes without auth | Route handlers / actions without auth | Endpoints without auth; DB config |
| TLS / HTTPS | Platform default | Depends on host | Strongest defaults | Check the deployment URL |
| Security headers | You add them | You add them | You add them (next.config) | You add them |
| Rate limiting on auth | You add it | You add it | You add it | You add it |
| Debug scaffolding | Check Edge Functions | Check routes | Check preview deploys | Check Agent leftovers |
The pattern is unmistakable: the platforms converge on infrastructure and diverge only in how the AI typically misconfigures the application layer. Your verification pass is the product, regardless of builder.
/.env, /.git/HEAD, /debug, /admin on the production URLcurl -IHttpOnly, Secure, SameSite)Run it before every deploy, and re-run it after every AI-assisted change. The builder got you to working; this gets you to shippable.
Whichever builder you used, the verification pass is the same afternoon of curl commands and greps — 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.
The free mini-scan checks your live homepage for TLS/HTTPS basics, response security headers, cookie flags, exposed sensitive files, Firebase/Supabase backend rules, and the WordPress plugin versions your site exposes. You get a score and the finding titles — no account, no card.
Run the free mini-scan →← Back home · Run a free mini-scan · Scan my app — $29 · See a sample report