Built fast. Now make it impenetrable.
Apps built with Lovable, Bolt, Cursor and friends ship fast and ship holes. Our AI red team finds them the way an attacker would, confirms each one, helps you fix it, and hands you a signed report you can show anyone.
- agent
- resolving…
- action
- finding.validate
- resource
- app.example.com/api/orders
- severity
- HIGH · broken access control
- issued
- 2026-09-02T14:03:07Z
- hash
- computing…
- sig
- signing…
- 1Scan authorized…
- 2Finding validated…
- 3Fix verified…
AI writes the app in a weekend. Nobody checks what it left open.
Vibe-coded apps work on the happy path. Attackers don’t use the happy path. The same four holes show up again and again, and each one is found by a script in minutes:
API keys and service credentials end up in the browser bundle or a public repo, because the AI put them where the code worked first.
Database rules left open by default: row-level security off, storage buckets public, so any signed-in user can read everyone else’s records.
Change an id in the URL and you see another customer’s order. Admin routes that check nothing. The most common hole in AI-generated apps.
No rate limits on login or signup, verbose errors that leak stack traces, and forms that trust whatever the browser sends.
Shipping fast is fine. Shipping open is not. We close it.
From “it works” to “it’s locked down” in four steps.
Scope
You point us at your app. Only yours.
We confirm you own the target and agree the scope in writing: which domains, which APIs, which test accounts. Nothing outside it is touched, ever.
ownership confirmed · written scope · nothing else touched
Attack
AI agents probe it like a real attacker.
Recon, auth, APIs, database rules and leaked secrets, following OWASP methodology. The agents chain small weaknesses the way a person would, not just run a checklist.
tested the way an attacker would, inside your scope
Confirm and fix
No guesses. Every finding is proven.
Each hole is confirmed with a working proof-of-concept, so there are no false alarms, and comes with a plain-English fix you can paste back into your AI builder.
- 3fix: owner check added
- 2PoC replayed 3/3
- 1HIGH · broken access
every finding confirmed with a proof, then fixed
Retest and report
We check the fix held, then sign off.
Once you patch, we retest every finding. You get a signed report that your customers, investors or auditor can verify for themselves.
anyone can verify the report, even offline
Every finding is a signed record, not a screenshot.
A PDF anyone could edit proves nothing. Each finding in your report is a signed entry: what was tested, what broke, the proof it was real, and a signature over all of it. Change one word and it fails.
{"v": "zanii-receipt/1","receipt": "rcpt_01J9F2QDX7A2K9RT4B6N1M8P0C","agent": "did:key:z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK"1,"scan": "scan_0412","action": "finding.validate"2,"resource": "app.example.com/api/orders","params": : {"severity": "high","class": "broken-access-control","poc": "replayed 3/3"},"issued_at": "2026-09-02T14:03:07.640Z","prev_hash": "3f9c1a08b47e2d6590c8f1a327bd4e6f8a0c5d921e3b7f406c9a2d8e5b1f0a73"3,"hash": "a71e3f5c9b2d84006f1c7e2a9d4b8c31e0f6a2b7c8d9e0f1234567890abcdef1","sig": "z3kFpTq7Nx2Vr8Ld5Ha1Wm9Cz6Bs4Yv0Gj7Kt3Qn8Rf2Xp5Md1Lb6Wa9Ce4Yh0Vs7Nu2Bx5Kq8Rt3Zf"4}
The testing agent that found it. Its key signs the finding, so the report can’t be quietly rewritten later.
Where the hole is, how bad it is, and the proof-of-concept that confirmed it. Real, reproducible, no false alarms.
The link to the step before it, from scope to fix. Remove or reorder a finding and the chain breaks.
The signature over everything above. It proves this report is exactly what the test produced, untouched since.
Your customers can check the report themselves.
When a customer or investor asks “is your app secure?”, send the report. The check runs in their browser, with no account and no call to us. It holds, or it doesn’t. Try it on the right.
- No login, no account, no need to trust us.
- Change any word in a finding and the check fails. Try it.
- Works on the exported report, today or years from now.
proof for customers, investors and auditors
For anyone who shipped fast and wants to sleep at night.
Built it with AI, launching soon
Before real users and real data arrive, make sure a curious stranger can’t read your database or take over an account.
Shipping client apps every week
Hand every client a signed security report with the site. Fewer 2 a.m. calls, and a reason to charge for the launch.
Enterprise buyer wants proof
Security questionnaires ask what you tested. Answer with a report the buyer can verify for themselves.
Due diligence on an AI-built product
Know what you are buying. Get an independent check of the app’s real security before the money moves.
The holes AI builders leave, checked one by one.
Lovable · Bolt · v0Cursor · Replit · Next.js-- Finding: any signed-in user can read every order -- Fix: turn on row-level security, allow owners only alter table orders enable row level security; create policy "owners read own orders" on orders for select using (auth.uid() = user_id); -- retested: user B can no longer read user A's orders
- Login
- brute-force limits, lockout, MFA
- Sessions
- cookie flags, expiry, logout
- Password reset
- token reuse and leakage
- OAuth
- redirect and state handling
- Object access
- change an id, see someone else’s data
- Admin routes
- reachable without the right role
- Tenancy
- one customer reading another’s
- File access
- direct links to private files
- Row security
- Supabase RLS / Firebase rules
- Storage
- public buckets, listable files
- Injection
- SQL and NoSQL, in every input
- Exports
- bulk data reachable by anyone
- Client bundle
- API keys shipped to the browser
- Repos
- keys committed to git history
- Env
- service keys where anon keys belong
- Third parties
- Stripe, OpenAI, email keys
- Rate limits
- signup, login, costly endpoints
- Validation
- trusting what the browser sends
- Errors
- stack traces and internals leaked
- CORS
- any site calling your API
- Headers
- CSP, HSTS, frame protection
- TLS
- certificates and redirects
- Dependencies
- known-vulnerable packages
- Exposure
- debug pages, backups, admin panels
The short answers.
Is this legal? Will you attack my site without asking?+
We only test apps you own, after you confirm ownership and we agree the scope in writing. We never touch anything outside that scope.
My app was built with Lovable, Bolt or Cursor. Can you still test it?+
Yes. That is exactly what we are built for. We know the patterns these tools produce and where they usually leave doors open.
Will testing break my live app?+
We test carefully and agree the approach first. Where it matters, we test against a staging copy or test accounts instead of real customer data.
Do you just send a list of problems?+
No. Every finding comes with a plain-English fix you can paste back into your AI builder. After you patch, we retest and confirm it is closed.
What does the signed report prove?+
That the findings, fixes and retest results are exactly what the test produced, unedited. Anyone can check the signature, even offline.
Find the holes before someone else does.
Send us your app’s address. We confirm you own it, agree the scope, and run the test. You get every finding with a proof and a fix, a retest after you patch, and a signed report to show your customers.