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 →You built an app with Bolt.new in an afternoon. It looks great, it works, and you're one click from putting it in front of real users. Before you do, here's the honest answer to the question in the title: Bolt generates working apps, not secure ones. That's not a knock — security was never the product's job. It becomes yours the moment you deploy.
This article covers what Bolt.new apps typically expose in the wild, how to check each one in minutes, and what to fix before you ship.
Bolt scaffolds full-stack apps — often React + Vite with server functions, or full Next.js projects — and deploys them fast. That speed creates a pattern: everything works, and everything is reachable. The typical Bolt-built app has:
.env setup where secrets got pasted in whatever way made the build passNone of this means your app is doomed. It means you have to verify the things the AI never thought about. Let's go through them.
This is the most common Bolt exposure. When you paste an API key into Bolt's environment variables and the AI references it in frontend code, the key can end up in your shipped JavaScript bundle — readable by anyone who opens DevTools.
Test it:
curl -s https://your-app.com | grep -o 'src="[^"]*\.js"' | head -5
Download the main JS bundle and search it:
curl -s https://your-app.com/assets/index-abc123.js | grep -iE 'sk_live|sk-test|AIza|AKIA|api_key|secret|bearer' | head
If you see a real key, it's public. Rotate it immediately and move it server-side.
Fix: Any key that starts with sk_, secret, or touches money/data must live in a server function, never in the browser bundle. In Bolt, that means using server-side route handlers (or Supabase edge functions with service-role keys) and calling them from the client — never importing the raw key in frontend code.
Bolt's AI will happily build an API route that reads or writes your database. It will not, by default, check who is calling it. A route like /api/users or /api/orders that works from a logged-in browser session will often work identically from a bare curl request with no cookies at all.
Test it — log out of your app first, then:
# Discover what routes exist
curl -s https://your-app.com/api/ -o /dev/null -w "%{http_code}\n"
# Hit the endpoints your app actually uses
curl -s https://your-app.com/api/users | head -c 500
curl -s -X POST https://your-app.com/api/create-order \
-H "Content-Type: application/json" \
-d '{"test": true}' | head -c 500
If you get 200 responses with real data while logged out, that endpoint is unprotected. Substitute the paths your app actually uses — check your Network tab to find them.
Fix: Every server route that touches data needs an auth check on the server, before any logic runs. Frontend route guards (if (!user) redirect) are cosmetic. The check has to live in the API handler or your row-level security policy.
A huge number of Bolt apps use Supabase, and here's the pattern that keeps showing up: the AI creates the tables, writes the queries, gets everything working — and never enables Row Level Security. With RLS off, anyone with your public anon key (which is in your client code by design) can read and write every table.
Test it: In the Supabase dashboard, go to each table and check whether RLS is enabled. Or test from the outside:
curl -s "https://your-project.supabase.co/rest/v1/your_table?select=*" \
-H "apikey: YOUR_ANON_KEY" \
-H "Authorization: Bearer YOUR_ANON_KEY" | head -c 500
If that returns rows, your tables are open. The anon key is not a secret — it's shipped in your frontend — so RLS is your actual access control.
Fix: Enable RLS on every table and write policies that scope reads and writes to the authenticated user (auth.uid() = user_id). Then re-test the query above — it should return nothing or an error for anonymous requests.
Bolt prototypes often include /debug, /test, /admin, or sample-data seed routes the AI built while iterating. These ship to production by default because nobody removed them.
Test it:
for path in /debug /test /admin /api/debug /api/test /seed /reset; do
code=$(curl -s -o /dev/null -w "%{http_code}" "https://your-app.com$path")
echo "$path -> $code"
done
Anything returning 200 on a path you don't recognize in production is a candidate for removal.
Fix: Delete debug routes and seed scripts before deploying. If you need admin tooling, put it behind real authentication — an unlinked URL is not access control.
Quick, free, and frequently absent:
curl -sI https://your-app.com | grep -iE 'content-security-policy|x-content-type-options|x-frame-options|strict-transport'
Bolt's default hosting typically won't set these for you. Add them at your hosting layer or in your framework config — they close off whole categories of clickjacking and content-injection attacks.
.env Isn't Where You Think It IsIf you built in Bolt and then exported to GitHub to deploy elsewhere, check what got committed:
git log -p -- .env .env.local | grep -iE 'key|secret|token|password' | head
Keys in git history stay compromised even after you delete the file. If anything was ever committed, rotate it — don't just remove it.
Run these in order before every deploy:
That covers the exposures that account for the vast majority of real-world Bolt app incidents.
The checks above take about 15 minutes once you know the paths — but it's easy to miss the API route you forgot existed, or the table whose RLS you thought was on. 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 you get a plain-English prioritized report of what to fix before you ship.
Don't want to do it by hand? PreShipIt scans your app from the outside for $29, one time.
Note on scope: 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.
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