In short
- Lovable, Bolt and Base44 run the database for you and let the browser query it: the access rules on each table are the only lock.
- Replit and v0 put the lock in server code: each API route or Server Action must check the session and the record's owner.
- Cursor and Claude Code have no default backend. Their reviews read code, so settings changed in a dashboard are invisible to them.
- Every vendor publishes certifications for its own platform. None covers the access rules of the app you built.
- The same six tests apply to all seven: the tool's own scan, the outside view, the rules, the bundle, a signed-out request and a second account.
On this page
- What "best" means on this page
- The main vibe coding tools, compared on security
- Hosted builders with a built-in backend: Lovable, Bolt, Base44
- Platforms where your own server code is the lock: Replit and v0
- Editors and agents: Cursor and Claude Code
- What is the same whichever you pick
- What to test, whichever tool you pick
- What Keybrum tests on each backend, and what it does not
- Questions
- Sources
What "best" means on this page
Most lists of vibe coding tools rank them on speed, design quality or price. This one compares them on a single question: when the app is live, what protects your users' data, and what is left for you to check? That is the question that matters the week real users arrive, and it is the one the usual lists skip.
We do not name a winner. Every tool below is a reasonable place to build. Lovable, Base44, Replit, Cursor and Claude Code state in their own documentation that what you ship is your responsibility, and none of the seven claims to verify your access rules for you. What differs is where each puts your data, which checks it runs for you and which layers it leaves in your hands. The facts come from each vendor's documentation, read on 13 November 2026. The list covers the seven tools we have a full guide for; it is not a census of the market.
The main vibe coding tools, compared on security
| Tool | Backend and where data lives | Built-in security check | Secrets | Certifications the vendor publishes |
|---|---|---|---|---|
| Lovable | Built-in PostgreSQL backend on Supabase's open-source foundation, queried from the browser; or your own Supabase project | Quick scan on every publish (database rules, dependencies, exposed MCP servers); Deep scan of the code on demand | Encrypted Secrets, injected into edge functions and server code | SOC 2 Type II, ISO 27001:2022, AIUC-1. Not HIPAA compliant |
| Bolt | Bolt database on every plan, queried from the browser; your own Supabase project on Pro and Teams | Database Security tab on all plans; project security audit of code and database on paid plans | Secrets page: values reach server functions only | SOC 2 Type 2; GDPR and CCPA compliance |
| Base44 | Managed entities on Base44's backend, read from the browser through its SDK | Security scan on all plans; static code analysis on Builder and above. Warns at publish, does not block | Encrypted vault, readable only by backend functions | SOC 2 Type II, ISO 27001, GDPR with a DPA on request |
| Replit | PostgreSQL 16 on Replit's infrastructure, reached through your API routes; separate development and production databases | Scan before publish; Level 1 dependency checks free; Level 2 code review and Level 3 black-box test of the Preview on paid plans | Secrets tool, AES-256 at rest, read as environment variables | SOC 2 Type II, GDPR; working toward ISO 27001 |
| v0 | Your pick from the Vercel Marketplace (Supabase, Neon, Upstash, Vercel Blob), used by a Next.js app on Vercel | Generated code analyzed before it runs; NEXT_PUBLIC_ warnings; a Security Check of a chat's changes on request | Vercel environment variables; only NEXT_PUBLIC_ ones reach the browser | Included in Vercel's SOC 2 Type 2 attestation |
| Cursor | None by default: your repository's stack. Apps hosting provisions a Postgres database | Bugbot and Security Review on pull requests; publish checks on hosted Apps | Your host's environment variables; Apps stop a publish that contains a key or token | SOC 2 Type II attestation, ISO/IEC 27001:2022, ISO/IEC 42001:2023, AIUC-1 |
| Claude Code | None: it writes code into your repository, and you choose where the app and its data run | /security-review on your branch's changes; a security guidance plugin during the session | Your host's environment variables | Anthropic's SOC 2 Type 2 report and ISO 27001 certificate, through its Trust Center |
Read the last column with care. A certification attests how the vendor runs its own platform. It does not cover the access rules inside the app you built, and no vendor here claims it does.
Hosted builders with a built-in backend: Lovable, Bolt, Base44
These three build the app and run its data for you. They share one design: the browser reads the database directly, so access rules are the only lock.
Lovable stores data in PostgreSQL behind row level security (RLS). The built-in backend is enabled by default. Its Quick scan runs automatically every time you publish and reviews database access rules, known npm vulnerabilities and MCP servers exposed without authentication. The Deep scan reads all application code but only when you start it. Lovable describes these scanners as static analysis and offers an optional AI pentest by Aikido for the running app. Its documentation says you are responsible for ensuring your app meets the security requirements of its use case. The Lovable security guide has the detail.
Bolt uses a Bolt database by default, which can be claimed into a Supabase account on Pro or Teams plans. It turns RLS on automatically for the tables it creates. Its help center is frank about two things: anyone who visits your site can send requests to your database directly, and without sign-in Bolt might write policies that allow any visitor to view, add, change and delete data. The database Security tab, on all plans, flags those policies. The project security audit, on paid plans, reviews code and database and uses no tokens. See the Bolt.new security guide.
Base44, owned by Wix, stores data in managed entities with row-level and field-level rules. Its reference states the default plainly: an operation with no rule stays open to everyone. In practice its AI adds rules when it creates a table and tells you which tables it covered. The security scan is available on all plans, the free one included, and checks permissions, user fields that rules rely on, private fields, exposed secrets, backend functions and more. It warns in the publish panel without stopping the publish. Since October 27, 2026, a Tenzai AI pentest can be run on the published app from the Builder plan up, billed by Tenzai. See the Base44 security guide.
Platforms where your own server code is the lock: Replit and v0
In these two, visitors do not query the database. They call code that runs on a server, and that code decides what they get.
Replit Agent builds an app with an API server and PostgreSQL 16. Development and production have separate databases, and Agent cannot modify the production one. Sign-in uses Clerk by default on Starter, Core and Pro. Replit's shared responsibility model is the clearest of the seven: it lists access control, user management and penetration testing of the application you build as yours. Its Security Center goes from free dependency checks (Level 1) to a code review (Level 2) and an external black-box test of the live Preview (Level 3). Apps in a personal workspace publish as Public by default. See the Replit security guide.
v0, by Vercel, generates a Next.js app and deploys it to Vercel, with a database added through the Vercel Marketplace. Its security page says it considers all code potentially incorrect or adversarial and analyzes it before it runs. It does not describe a sign-in system of its own: you prompt for one. The Next.js documentation adds the rule that matters most here: an exported Server Action is reachable by a direct POST request, so authentication and authorization must be verified inside each one. See the v0 security guide and the Next.js security guide.
Editors and agents: Cursor and Claude Code
These write code into your repository. They have no default backend, so the database, the hosting and every setting are choices you make and own.
Cursor reviews changes. Bugbot analyzes pull request diffs for bugs and security issues, and Security Review checks pull requests before they merge. Its optional Apps hosting provisions a Postgres database, puts private and team apps behind Cursor sign-in, and on every publish stops on hardcoded keys and credential files, leaves .env files out and removes source maps. Its Apps documentation says Cursor is not responsible for your apps, including your prompts and any outputs. See the Cursor app security guide.
Claude Code, by Anthropic, is a coding agent for the terminal and the IDE. Its security documentation is mostly about the agent on your machine: permission modes, a sandbox and a trust dialog. For the code it writes, /security-review runs a security pass over the changes on your current branch. It hosts no app and no database, and its docs say you are responsible for reviewing proposed code and commands. See the Claude Code app security guide.
What is the same whichever you pick
Across the seven tools, the leak is in the deployed app, and it comes from the same three places:
- The rules on the data. RLS policies on Supabase, entity rules on Base44, security rules on Firebase, or the owner check in an API route. The public measure is CVE-2025-48757: 170 of 1,645 Lovable apps scanned had missing or weak RLS, about one in ten. The mechanism is the stack's, and other tools on the same stack share it.
- Keys in the bundle. Anything behind
VITE_orNEXT_PUBLIC_, or pasted into frontend code, is in every visitor's browser. Public keys belong there. Secret keys never do. See API keys exposed in the frontend. - Per-user access. A rule that checks sign-in and forgets the owner lets any new account read every record. That is an IDOR, the access bug we find most often in generated apps.
The built-in checks reduce these mistakes, and they are worth running every time. Almost all of them read rules and code. The exceptions test something other than your public address by default, or are sold by a partner: Replit's Level 3 targets the Preview, and the Aikido and Tenzai pentests are billed separately. Vibe coding security risks explains why generated apps keep shipping the same holes.
What to test, whichever tool you pick
Run these on your own app only. They take under an hour and apply to all seven.
- 1
Run the tool's own deepest check
Lovable Deep scan, Bolt security audit, Base44 security scan, Replit Security Center, a v0 Security Check, Cursor's
/review-securityor Claude Code's/security-review. Fix what it finds, then publish again. - 2
Look at the app from outside
Paste the published address into the free check. It shows which backend the app talks to, the keys in its JavaScript and the tables its code names.
- 3
Read the rules on the data
On a Supabase-style database (Lovable, Bolt, often v0, Cursor and Claude Code), run the SQL below. On Base44, open each table's Permissions page. On Firebase, paste your rules into the Firebase rules checker. With your own API, list every route and find its owner check.
- 4
Search what ships for secret keys
Paste the published JavaScript into the API key leak checker, or run the grep below on a build.
- 5
Ask for private data with no session
In a private window, open the Network tab, copy a data request as cURL, remove the
CookieandAuthorizationheaders and run it. No private record should come back. - 6
Repeat as a second account
Sign up twice. As account B, request a record that account A created, by its id. Then call your AI feature signed out: a model's answer means anyone can spend your credits.
-- 1. Tables in the public schema with row level security off
select tablename
from pg_tables
where schemaname = 'public' and not rowsecurity;
-- 2. Policies that let every caller through
select tablename, policyname, cmd, roles
from pg_policies
where schemaname = 'public'
and (qual = 'true' or with_check = 'true');# On a build of your own app: secret keys must not ship to the browser
npm run build
grep -rnoE "sk_live_[A-Za-z0-9]{10}|sk-proj-[A-Za-z0-9_-]{10}|sk-ant-[A-Za-z0-9_-]{10}|sb_secret_[A-Za-z0-9_-]{6}|BEGIN [A-Z ]*PRIVATE KEY" dist build .next/static 2>/dev/null
# On your live address: this must not return your environment file
curl -s https://YOUR-APP.example/.env | head -n 5The full list, layer by layer, is the vibe coding security checklist.
What Keybrum tests on each backend, and what it does not
Keybrum is the automated pentest we build for apps made with these tools. It attacks the published app from outside, proves each finding with the request that worked, and attacks again after the fix. It does not care which tool wrote the code; its coverage depends on the backend it finds, and it is not equal everywhere.
| Backend | Typical tools | What Keybrum tries |
|---|---|---|
| Supabase-style database | Lovable, Bolt; often v0, Cursor, Claude Code | Reads, inserts and updates on every table it can list, as a stranger and as a new account; one account's rows from a second account; database functions, storage buckets, realtime channels, AI edge functions |
| Base44 entities | Base44 | Reads each entity named in the JavaScript with no session. Read-only. No write tests and no signed-in cross-account test today |
| Your own API | Replit, v0, Cursor, Claude Code | Every route the JavaScript calls, with no session; a marked record created by one account and requested by another; Next.js middleware bypasses and Server Action flaws from public CVEs, proved by behaviour |
| Firebase | Apps written with Cursor or Claude Code, or any app that connects Firebase | Firestore, Realtime Database and Storage rules, tested as a stranger |
| Any stack | All seven | Secret keys in the bundle, each checked with a read-only call; unsigned Stripe webhooks; open AI routes; served .env files, source maps and security headers |
What it does not test: the builders and editors themselves, your workspace or plan settings, the agent on your machine, and your code as written. Databases that are not reachable from outside, such as Replit's or Neon, are tested only through your routes. Delete access is never tested. Keybrum attacks only apps whose owner proved ownership.
A one-time report costs €49 for one app. Plans start at €29 a month excluding VAT for 5 apps and attack again on every deploy. The Team plan, €99 a month, covers 25 apps and puts your brand on reports and trust pages, which suits agencies that deliver apps built with several of these tools.
Questions
What is the most secure vibe coding tool?
No tool makes the app safe on its own. All seven compared here publish security certifications for their platform, and all of them leave your app's access rules to you. Pick on fit, then verify the rules, the keys in the bundle and per-user access on the live app.
What are the main vibe coding tools in 2026?
The ones compared here are Lovable, Bolt, Base44, Replit and v0 among hosted builders and platforms, and Cursor and Claude Code among editors and agents. Others exist and are not covered on this page. The comparison is as of November 2026.
Which vibe coding platforms include a database?
Lovable, Bolt, Base44 and Replit include one. v0 connects one through the Vercel Marketplace, such as Supabase or Neon. Cursor provisions a Postgres database only for apps hosted with its Apps feature, and Claude Code includes none.
Do vibe coding tools scan my app for security issues?
Most do, in different ways. Lovable scans on every publish, Bolt and Base44 offer a scan and an audit, Replit has three scan levels, and Cursor and Claude Code review code changes. Nearly all of these read rules and code; they do not send requests to your published app.
Is a SOC 2 certified builder enough for my customers?
It answers one question: how the vendor runs its own platform. Your customer's question is usually about your app: who can read their data. That depends on your access rules, which the vendor's certification does not cover. A test of the live app, with a report, answers it.
Are apps built with vibe coding tools safe for production?
They can be, once the access rules are verified. The known failures are specific and checkable: tables without row level security, secret keys in the browser, and routes that skip the owner check. Run the six tests on this page before real users arrive, and again after each change.
Sources
- 1.Security overview, Lovable Docs
- 2.Built-in backend, Lovable Docs
- 3.FAQ: tech stack and compliance, Lovable Docs
- 4.Check your project's security, Bolt Help Center
- 5.Database security settings, Bolt Help Center
- 6.Security that keeps up with you, Bolt
- 7.Base44 security: An overview, Base44 Docs
- 8.Base44 entities: Row-level security (RLS), Base44 Docs
- 9.Running a security scan, Base44 Docs
- 10.Product changelog, Base44 Docs
- 11.Replit shared responsibility model, Replit Docs
- 12.Security scan levels, Replit Docs
- 13.Development and production databases, Replit Docs
- 14.Replit security, Replit
- 15.Security, v0 Docs
- 16.Full-stack apps, v0 Docs
- 17.Databases, v0 Docs
- 18.How to think about data security in Next.js, Next.js Docs
- 19.Apps (hosting, publish checks and terms), Cursor Docs
- 20.Bugbot, Cursor Docs
- 21.Security Agents, Cursor Docs
- 22.Security, Cursor
- 23.Security, Claude Code Docs
- 24.Statement on CVE-2025-48757, Matt Palmer