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 →v0 generates beautiful Next.js apps fast — and deploys them to Vercel even faster. Vercel handles a lot of infrastructure security for you (TLS, edge network, DDoS absorption), which is genuinely valuable. But the application layer is yours: the routes, the auth checks, the secrets, the headers. That's where v0-generated apps have a predictable set of gaps.
This article walks through what to verify in a v0-generated Next.js app before you put real users on it.
Credit where it's due — a Vercel deployment includes, by default:
*.vercel.app and custom domains, with automatic renewalThose cover the transport layer. Everything below is what Vercel does not do for you — and what v0's AI does not do by default.
v0 loves generating app/api/**/route.ts handlers — /api/users, /api/orders, /api/checkout — wired to your database. It does not, by default, verify who is calling them. A route that returns user data to your logged-in frontend will usually return the same data to a bare curl request with no cookies.
Test it — log out of your app first:
# Find the routes your app actually calls (check the Network tab in DevTools)
curl -s https://your-app.vercel.app/api/users | head -c 400
curl -s -X POST https://your-app.vercel.app/api/orders \
-H "Content-Type: application/json" -d '{"test": true}' | head -c 400
A 401/403 is correct. A 200 with real data means the endpoint is public.
Fix: Every route handler that touches data needs a server-side auth check before any logic runs — verify the session or JWT at the top of the handler. Frontend route guards (if (!user) redirect('/login')) are cosmetic; they don't protect the API.
Next.js has a clear rule: any environment variable starting with NEXT_PUBLIC_ is embedded into the client bundle. v0-generated code sometimes reaches for NEXT_PUBLIC_ to make a value available in a component — and if that value is a secret, it's now public.
Check it:
# In your repo: find every client-exposed variable
grep -rn "NEXT_PUBLIC_" --include="*.ts" --include="*.tsx" --include="*.js" app/ components/ | head -30
Read each one. Analytics IDs and publishable keys are fine. Anything starting with sk_, containing secret, or unlocking an API is not — move it to server-only code (Route Handlers, Server Components, Server Actions) and read it from process.env without the NEXT_PUBLIC_ prefix.
Then verify the shipped bundle. Download the production JS and grep for key patterns (sk_live, sk-, AIza, service_role). The browser should never contain them.
React Server Components run on the server — good — but v0 sometimes fetches more data than the page displays ("just in case") and passes it down as props. Props get serialized into the HTML. If a server component fetches a full user record including internal fields and passes it to a client component, those fields ship to the browser.
Check it: Open your app's pages, view source, and search the initial HTML for fields that shouldn't be there — internal IDs, emails of other users, tokens, admin flags. Fetch only what the page renders; select columns explicitly instead of select('*').
Server Actions need the same auth treatment as route handlers: verify the caller at the top of every action that mutates data.
v0-generated apps commonly connect to Postgres (Neon, Supabase) via a connection string. That string belongs in Vercel's environment variables (Production scope), never in the repo:
git log -p --all | grep -oiE 'postgres(ql)?://[^ "]*' | head -10
If a connection string was ever committed, rotate it — database credentials in git history stay compromised. Also confirm your database itself requires authentication over TLS and isn't configured to accept connections from anywhere without a password. The connection string is not access control; the database's own auth is.
Vercel doesn't set application security headers for you. Check what's actually served:
curl -sI https://your-app.vercel.app | grep -iE 'strict-transport-security|content-security-policy|x-content-type-options|x-frame-options|referrer-policy'
Add them in next.config.js via the headers() function — that's the standard Next.js mechanism:
Strict-Transport-Security (long max-age; you've already got HTTPS)Content-Security-Policy (start reasonable, tighten later)X-Content-Type-Options: nosniffframe-ancestors (modern) or X-Frame-Options (legacy fallback)Two quick probes that catch deployment mistakes:
for p in /.env /.git/HEAD /api/debug /debug /test; do
echo "$p -> $(curl -s -o /dev/null -w '%{http_code}' https://your-app.vercel.app$p)"
done
A 200 on /.env is an emergency (rotate everything, fix the deployment). Debug routes the AI added while iterating should be deleted, not left unlinked. Vercel's deployment model makes /.git/HEAD unlikely, but the check costs five seconds — run it anyway.
Also check Access-Control-Allow-Origin: if your API serves only your own frontend, it should name your domains, not *.
Two v0/Vercel-specific habits:
v0 often scaffolds auth with a library (NextAuth/Auth.js, Clerk, Supabase Auth). The library is fine; the wiring is where it breaks:
HttpOnly, Secure, and SameSite=Lax or stricter — inspect them in DevTools → Application → CookiesIn order: logged-out curl of every /api route → NEXT_PUBLIC_ audit → shipped-bundle key grep → git history grep for connection strings → headers check → /.env and debug-route probes → preview deployment review → auth wiring check. Thirty minutes, once per deploy, and re-run after any AI-assisted change that touches routes or integrations.
The checks above are straightforward, but they're easy to skip — and the route you forgot to test is the one that's open. 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