In short
- Both builders let the browser query PostgreSQL directly. Bolt's help center says anyone who visits your site can send requests to your database without using your screens.
- Bolt turns RLS on for the tables it creates, and warns that without sign-in it might write policies letting any visitor view, add, change and delete data.
- Lovable's Quick scan runs on every publish. Bolt's project security audit is on paid plans, up to 30 a day, and uses no tokens; its database Security tab is on all plans.
- RLS being on is not the finish line on either: a policy whose condition is
true, or one that never checks the owner, passes as a policy. - The same SQL and the same request test a Lovable and a Bolt database, because the stack is the same.
On this page
Lovable vs Bolt: the short answer
On security, Lovable and Bolt are the closest pair among AI app builders. Both give you a built-in PostgreSQL database with sign-in, file storage and server functions. In both, the published site talks to that database directly, and row level security (RLS) policies decide what a visitor can read or change. Bolt's own help center says it without softening: anyone who visits your site can send requests to your database directly, without using your site's screens.
So the choice between them does not change the kind of leak you can ship. What differs is how each sets the database up, what its scanner covers and on which plan. This page compares only that, from each vendor's documentation as of 13 November 2026, and names no winner on features or price. For each tool alone, read the Lovable security guide and the Bolt.new security guide.
Where each one puts your data
Lovable: the built-in backend is enabled by default and, in Lovable's words, uses Supabase's open-source foundation. It holds the database, users, storage, edge functions and secrets. You can connect your own Supabase project instead.
Bolt: new projects use a Bolt database by default, available with every plan. Bolt creates it automatically when the project needs one. On a Pro or Teams plan you can start with your own Supabase project, or claim an existing Bolt database into a Supabase account, where it appears as a Supabase project. The database Security tab uses the same checks as the Security Advisor in Supabase.
| Lovable | Bolt | |
|---|---|---|
| Default database | Built-in backend on Supabase's open-source foundation (PostgreSQL) | Bolt database on every plan; it can be claimed into Supabase on Pro or Teams |
| Your own Supabase project | Yes, as an alternative to the built-in backend | Yes, on Pro and Teams plans |
| How the site reaches data | Directly from the browser, with a publishable key | Directly from the browser: visitors can send requests to the database without using your screens |
| RLS on new tables | Lovable sets up rules automatically when it builds features that store user data | Bolt turns RLS on automatically for the tables it creates. Tables you add yourself are yours to check |
| Secrets | Encrypted Secrets, injected into edge functions and server code, never sent to the browser | Secrets page: values available only to server functions, never written to project files, browser code or the published site |
| Hosting | Lovable | A bolt.host address; custom domains and private sites on paid plans. On the Free plan every published site is public |
| Data region | Americas, Europe or Asia Pacific, fixed once the backend is enabled | Not stated on the pages we read |
| Certifications the vendor publishes | SOC 2 Type II, ISO 27001:2022, AIUC-1. Not HIPAA compliant | SOC 2 Type 2, with GDPR and CCPA compliance |
What each protects by default
Both keep secret keys on the server when you store them in the right place. Lovable goes one step further on naming: it rejects VITE_ names in Secrets, since a VITE_ value is built into the browser bundle. Bolt never shows a secret's value again after you save it.
On the database, both turn the lock on. The question is what the policy behind it says. Supabase's documentation states the rule that applies to both stacks: with RLS enabled and no policy, the public key gets no data; a table without RLS is readable and writable by any role with a grant on it.
Bolt suggests sorting every table into one of three cases, which is a good habit on Lovable too. Visitors can only view the data, like a menu or blog posts. Visitors can submit information without reading what others submitted, like a contact form. Or the data is private, which requires sign-in, because policies can limit data to specific people only when the site knows who each visitor is.
Once sign-in exists, the mistake moves one step on both. A policy for signed-in users that never compares the row's owner with auth.uid() gives every account every row, and creating an account takes a stranger one form.
The security tools each one gives you
| Lovable | Bolt | |
|---|---|---|
| Database check | Part of the Quick scan: access rules and settings | Database Security tab, on all plans: RLS Policy Always True, Function Search Path Mutable, Leaked Password Protection Disabled |
| Runs on publish | Quick scan, automatically, every time you publish | An automatic review you turn on once, per Bolt's security page; the help center recommends an audit at least once before you publish |
| Code review | Deep scan: all application code across seven areas, started by you | Project security audit: code and database, on paid plans, up to 30 a day |
| What the code review looks for | Access control, unauthenticated endpoints, injection, leaked secrets, payments, authentication, exposed personal data | Who can see and change data, what the app makes public, sign-in, misuse such as changing a price, visitor input, keys and security settings |
| Fixes | From the Security view or the project chat | Bolt fixes what it can; neither the audit nor its fixes use tokens. The rest is listed under Needs your action |
| Dependencies | Known npm vulnerabilities, in the Quick scan | Not listed among the audit's areas |
| Third-party options | Wiz static analysis; Aikido AI pentest on the running app, billed by Aikido | None named on the pages we read |
Each has a point in its favour. Bolt's audit does not use tokens and looks for misuse of the app's logic, a kind of bug that a settings check cannot see. Lovable's Quick scan runs on every publish without being asked, on every project, and adds dependencies and exposed MCP servers.
The shared limit is the vantage point. Lovable says its built-in scanners perform static analysis and cannot guarantee complete security. Bolt describes an audit that reviews your whole project, including your code and database; its help center does not describe it as sending requests to the published site. Both read what you wrote. A stranger sees what the published site answers.
What is the same on both
Whichever you choose, the leak is in the deployed app, and it has the same three causes:
- The rules on the data. CVE-2025-48757 came from a scan of 1,645 Lovable apps: 170 of them, about one in ten, had missing or weak RLS across 303 endpoints. Bolt apps use the same kind of database, queried the same way from the browser. Nobody has published a comparable count for Bolt, and the mechanism is identical.
- Keys in the bundle. The database address and the public key are meant to be in your JavaScript. A Stripe secret key, an AI provider key or a service role key is not, and both builders ship whatever you paste into frontend code or a
VITE_variable. See the service role key guide. - Per-user access. Neither scanner knows which of your tables is private. A second account that reads the first account's orders is an IDOR, and it passes a check that only asks whether RLS is on.
Server functions are the fourth place, also shared. A function keeps a key off the browser. It does not decide who may call it. An AI or email function that answers any caller runs on your account, see unprotected AI endpoints.
A self-check that works on either
Because the stack is the same, the same queries and the same request work on both. Run them on your own project only.
- 1
Run the built-in checks
Lovable: the Deep scan from the Security view. Bolt: Publish, then Run security audit on a paid plan, and the database Security tab on any plan. Do every item under Needs your action.
- 2
Open the SQL editor
Lovable: in the Database view, select Manage, then SQL editor. Bolt: click the database icon in the top center, open a table, click Query, replace the query and click Run Query.
- 3
List open tables and open policies
Run the two queries below. The first lists tables with RLS off. The second lists policies whose condition is
true. For each result, decide which of the three cases the table belongs to: view only, submit only, or private. - 4
Review the policies that remain
Paste a policy into the Supabase RLS checker to read it line by line. A policy for
authenticatedmust mentionauth.uid()unless every signed-in user should see every row. - 5
Ask a private table as a stranger
Send the request below with the address and public key your site already ships. An empty list or an error is the right answer for a private table.
- 6
Repeat as a second account
Sign up twice in the published app. Create a record with the first account and try to open it with the second, for example by changing an id in the address bar.
-- 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');# Your own project and your own public key only.
curl "YOUR_DATABASE_ADDRESS/rest/v1/YOUR_TABLE?select=*&limit=1" \
-H "apikey: YOUR_PUBLIC_KEY"
# [] or an error: the table refuses strangers. A row: it does not..env, as VITE_SUPABASE_URL and VITE_SUPABASE_PUBLISHABLE_KEY.What stays your job before real users arrive
- Every table is sorted into view only, submit only or private, and its policies match that case
- No policy with the condition
trueon a table that holds private or editable data - Policies for signed-in users compare the row's owner with
auth.uid() - Tables you created by hand have RLS on: Bolt only turns it on for the tables it creates
- Buckets that hold user uploads are private, see Supabase storage security
- No secret key in project files or a
VITE_variable, and every key that ever shipped has been rotated - Every server function that calls an AI model, sends email or changes data checks the caller's session
- The check was repeated after the last feature: a new prompt can rewrite a policy
If you connected or claimed your own Supabase project, on either builder, its settings are yours to manage. The Supabase security guide covers that side, and the vibe coding security checklist covers the rest.
What Keybrum tests on each, and what it does not
Keybrum is the automated pentest we build for apps made with AI. Since Lovable and Bolt ship the same kind of backend, it runs the same attacks on both, against the published site.
- It lists the tables the public key can reach, from the API's own schema and from your JavaScript, then reads them as a stranger and as a brand-new account.
- It tries inserts and updates, and tries to give its own test account a role, a plan or credits it should not be able to set.
- It reads one account's rows from a second account.
- It calls database functions, lists and uploads to storage buckets, and subscribes to realtime channels.
- It sends a short prompt to server functions that look like AI endpoints, to see whether a model answers without an account.
- It looks for secret keys in the bundle and in rows a stranger can read, and sends an unsigned event to a Stripe webhook.
Every finding comes with the request that worked, personal data redacted, and the fix to paste into the builder's chat. Reads keep counts, column names and one redacted row. Delete access is never tested.
What it does not do: it does not read your project's code inside Lovable or Bolt, it does not see your workspace or plan settings, and it does not replace the builders' audits, which catch things in code that no outside request reveals. It only attacks apps whose owner proved ownership. A one-time report costs €49. Plans start at €29 a month excluding VAT for 5 apps and attack again on every deploy, which is when a prompt rewrites a policy.
Questions
Is Bolt or Lovable more secure?
They ship the same kind of backend, with the same lock: row level security policies on a PostgreSQL database that the browser queries directly. Both add a scanner. Which app leaks depends on the policies in that project, so compare what you will check, then check it.
Do Lovable and Bolt both use Supabase?
Lovable says its built-in backend uses Supabase's open-source foundation. Bolt's database can be claimed into a Supabase account, and its Security tab uses the same checks as Supabase's Security Advisor. Both also let you connect your own Supabase project, on Pro and Teams plans for Bolt.
Does Bolt turn on row level security automatically?
Bolt's help center says it turns RLS on automatically for the tables it creates, and that tables you add yourself need checking. It also warns that without sign-in, Bolt might write policies that let any visitor view, add, change and delete data. RLS being on is the start: read the policies.
Is the Bolt security audit free?
The project security audit is available on paid plans, up to 30 times a day, and neither the audit nor its fixes use tokens. The database Security tab is available on all plans. Lovable's Quick scan runs on every publish.
Can the same SQL check both a Lovable and a Bolt database?
Yes. Both are PostgreSQL with row level security, so a query on pg_tables lists tables with RLS off and a query on pg_policies lists policies whose condition is true. Run them in Lovable's SQL editor or in Bolt's Query view.
Sources
- 1.Security overview, Lovable Docs
- 2.Built-in backend, Lovable Docs
- 3.Secrets, Lovable Docs
- 4.Control who can access your app's data, Lovable Docs
- 5.Database, Lovable Docs
- 6.FAQ: tech stack and compliance, Lovable Docs
- 7.Check your project's security, Bolt Help Center
- 8.Database security settings, Bolt Help Center
- 9.Secrets, Bolt Help Center
- 10.Add and manage a built-in database in your Bolt project, Bolt Help Center
- 11.Supabase for databases, Bolt Help Center
- 12.Database tables, Bolt Help Center
- 13.Publish your project to a live website, Bolt Help Center
- 14.Security that keeps up with you, Bolt
- 15.Row Level Security, Supabase Docs
- 16.Statement on CVE-2025-48757, Matt Palmer