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 →Your site's security headers are instructions your server sends with every response, telling browsers how to behave: don't let this page be framed, don't sniff content types, only load scripts from these sources. They're free, they're one config change each — and AI coding tools almost never set them.
Below are the six headers a real scan checks (this is exactly the header set PreShipIt's passive first pass evaluates), what each one does, and how to verify yours in about two minutes.
The fastest way to see your headers is curl:
curl -sI https://your-app.com | grep -iE "strict-transport|content-security|x-frame|x-content-type|referrer|permissions-policy"
Or in Chrome: DevTools → Network tab → click the document request → Response Headers. Now compare against the six below.
What it does: tells browsers to only ever talk to your site over HTTPS, killing SSL-stripping attacks where an attacker downgrades a visitor to plain HTTP.
What good looks like:
Strict-Transport-Security: max-age=31536000; includeSubDomains
The max-age should be at least 31,536,000 (one year). A scan flags three separate things here: HSTS missing entirely (high severity), a weak max-age under a year (medium), and missing includeSubDomains (low — your subdomains stay downgradeable). preload is an extra opt-in for browser preload lists; only add it after confirming every subdomain is HTTPS-ready, because removal is slow.
What it does: declares which sources the browser may load scripts, styles, images, and other resources from. It's the single strongest defense against cross-site scripting landing on your users.
What good looks like: a restrictive policy without unsafe-inline or unsafe-eval in script-src. If your CSP contains those source expressions, a scanner flags it as medium severity — they're the escape hatches that make the rest of the policy decorative.
The vibe-coding problem: AI tools love inline scripts and eval-style patterns. When you bolt a CSP onto an AI-generated app, half the app breaks — so the AI either skips the header or ships script-src 'unsafe-inline', which protects nothing. The fix is nonces or hashes on your script tags, scoped source lists, and testing in report-only mode first (Content-Security-Policy-Report-Only) so you see breakage before you enforce.
What it does: stops other sites from embedding your pages in an iframe, which is how clickjacking works — an attacker frames your "delete account" page invisibly under a "click to win" button.
What good looks like:
X-Frame-Options: SAMEORIGIN
or the modern equivalent inside your CSP:
Content-Security-Policy: ...; frame-ancestors 'self'
A scan checks for either and flags it medium severity when neither is present. If you need embeds (payment widgets, partner iframes), whitelist exact origins instead of leaving framing open.
What it does: stops browsers from "sniffing" a file's content type when the declared type and the actual content disagree — the trick behind attacks that upload a "profile picture" that's actually HTML/JS and get the browser to execute it.
What good looks like: exactly one value:
X-Content-Type-Options: nosniff
Anything else — missing header, a different value — gets flagged. This one is a single line in any server or CDN config, and AI-generated apps miss it constantly because no demo ever broke without it.
What it does: controls how much of your URL leaks to other sites when users click outbound links. The default browser behavior sends the full URL (including tokens or IDs in query strings) to any linked site.
What good looks like:
Referrer-Policy: strict-origin-when-cross-origin
or stricter (same-origin, no-referrer) depending on your needs. Flagged as low severity when missing — it's a privacy leak, not an active exploit, but it's one line.
What it does: lets you switch off browser features your site doesn't use — camera, microphone, geolocation — so a compromised script can't reach them.
What good looks like: explicitly disabling what you don't need:
Permissions-Policy: camera=(), microphone=(), geolocation=()
Missing entirely is a low-severity finding. The fix is to enumerate the features your app actually uses and lock the rest down.
Headers are the cheapest signal in security — one curl and you know the posture. But they're also only the surface. The same passive pass that reads these headers also checks your TLS certificate (expiry, trust, protocol version), your cookie flags (Secure, HttpOnly, SameSite), and whether your /.env or /.git/HEAD is publicly reachable — plus whether plain-HTTP requests actually redirect to HTTPS.
Free header graders exist and they're fine for a quick look. If you want all of that in one pass, written up in plain English with the fixes in priority order, that's the $29 PreShipIt scan: paste your URL, confirm you own the app, and the report lands in about ten minutes.
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