v0 by Vercel Security: What to Check in Your Generated App

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 by Vercel Security: What to Check in Your Generated App

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.

Start With What Vercel Gives You

Credit where it's due — a Vercel deployment includes, by default:

Those cover the transport layer. Everything below is what Vercel does not do for you — and what v0's AI does not do by default.

Check 1: API Route Handlers Without Auth

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.

Check 2: Secrets in Client Components

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.

Check 3: Server Components and Actions Leaking Data

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.

Check 4: Database Credentials and Connection Strings

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.

Check 5: Security Headers

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:

Check 6: Exposed Files and Debug Routes

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 *.

Check 7: Preview Deployments and Shared Chats

Two v0/Vercel-specific habits:

Check 8: Auth Library Wiring

v0 often scaffolds auth with a library (NextAuth/Auth.js, Clerk, Supabase Auth). The library is fine; the wiring is where it breaks:

The v0 Pre-Deploy Pass

In 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.

Don't Want to Do It by Hand?

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