In short
- Lovable Cloud, called the built-in backend in the docs, uses Supabase's open-source foundation. You manage it from views inside Lovable, with no Supabase account and no Supabase dashboard.
- Lovable manages backups, instance size, the database password and auth settings. It does not decide who may read each row: that is your RLS policies.
- The publishable key is in your JavaScript and works from anywhere. A policy that only checks
authenticatedgives every signed-up user the same rows. - By default Lovable's agent may change your schema, your policies and your data without asking. Only migrations that break the published app are set to Never allow.
- Public storage buckets are blocked by default, and publishing with unresolved critical findings opens a review dialog. Both help. Neither tests the live app.
On this page
What Lovable Cloud is
Lovable Cloud is the backend that comes with a Lovable project. The documentation calls it the built-in backend and says you also see the name Cloud in parts of the product, such as your Cloud credit usage and the Enable Cloud permission. It gives an app a PostgreSQL database, user accounts, file storage, realtime updates and edge functions, without any setup.
The built-in backend utilizes Supabase's open-source foundation, which means you get a production-ready environment from day one, without needing to set up Supabase separately.
It is enabled by default for a workspace. When you ask for a feature that stores data or signs people in, Lovable turns the backend on, or asks first, depending on your permissions. The database, the user accounts and the storage run together: enabling one provisions all three. You choose a region among Americas, Europe and Asia Pacific, and it cannot be changed afterwards. Usage is paid in credits from your Lovable workspace.
So Lovable Cloud is a way to get Supabase's building blocks without owning a Supabase project. That convenience raises one question for security: what did Lovable take over, and what did it leave with you?
Lovable Cloud or your own Supabase project: what differs
Lovable still supports connecting a Supabase project you own. Its docs compare the two, and we added the security consequences in the last column.
| Lovable Cloud | Your own Supabase | For security | |
|---|---|---|---|
| Account and billing | None extra. Lovable credits | Your Supabase account and plan | One login less to protect with Cloud. With your own project, the Supabase account and its access token are yours to guard |
| Where you manage it | Database, Users and Storage views inside Lovable | The Supabase dashboard | Cloud has no Supabase dashboard. You read policies in a read-only view and change them through the chat or the SQL editor |
| Auth settings | Configured through Lovable | Configured in Supabase | Same settings to check either way: sign-up open or closed, email confirmation, leaked-password check |
| Backups and password | Daily backups kept roughly 14 days. Lovable rotates the database password on request | Managed by you in Supabase | Cloud gives you a restore without setup. Rotation by Lovable does not cover your own project |
| Lovable's checks | Database review at publish, a review dialog on critical findings, signed-in browser testing | The database review runs. Signed-in testing does not | More of Lovable's own tooling applies on Cloud |
| Access rules | Your RLS policies | Your RLS policies | No difference. This is where apps leak |
Switching later is manual in both directions. Lovable does not move a project from the built-in backend to your Supabase project in one step: you export the database, restore it, move the files and set up auth and secrets again. The docs advise deciding early.
What Lovable takes care of
Credit where due: several defaults of the built-in backend remove mistakes that are common on a hand-run project.
- Infrastructure. Hosting, instance size, daily database backups and the database password are managed for you. You never see the password, and you can ask Lovable to rotate it.
- Public buckets are blocked. The storage docs state that public storage buckets are blocked by default on all plans. A workspace owner or admin has to lift that block on purpose.
- A check at every publish. The Quick scan runs when you open the publish dialog and reviews database access rules, dependencies and MCP server exposure. On the built-in backend, unresolved critical findings open a Review security findings dialog before you publish.
- Destructive migrations need a decision. The permission to run migrations that may break the published app, such as dropping or renaming a table or column, is set to Never allow by default.
- Policies written for you. Lovable sets up row level security when it builds a feature that stores user data, and you can ask it to review who can reach what.
Lovable is also clear about the limit of these tools. Its security page says they "do not replace a thorough security review", and the permission that runs automated checks on your database is described as "Not a full audit". The scans are covered in detail in our Lovable security guide.
Where you still write the rules
The architecture is the same as Supabase's. Your app's pages read and write the database directly from the browser with a publishable key. Lovable's docs say that anyone using your app can see that key, that this is intended, and that "the key works from anywhere, not only from your app". A stranger does not need your pages. They need the backend address and the key, and both are in your JavaScript.
What stops them is row level security (RLS): rules in the database that decide which rows each caller may read or change. Every request arrives as one of three roles, and the docs explain the trap in plain terms.
| Role | Who it is | What your policies do |
|---|---|---|
anon | Anyone with the publishable key, signed out | Apply. A policy open to anon is open to the internet |
authenticated | Anyone who signed up and signed in | Apply. A policy that checks only this role gives every user the same rows |
service_role | Your server code with the admin client | Do not apply. The code must check permissions itself |
If a policy checks only for authenticated, every signed-in user gets the same access to every row that policy covers.
This is the mistake behind CVE-2025-48757, where 170 of 1,645 Lovable apps tested had missing or weak RLS, and behind the readable databases described in our page on the Lovable data leak reported in November 2026. A managed backend does not change it, because the policy is part of your app and not of the infrastructure. The Supabase RLS guide explains how to write one that compares the caller with the row's owner.
- Server code is a second door. Apps created since 13 May 2026 run on TanStack Start and have a server-only admin client that skips your policies. Older apps use edge functions. The docs warn that anyone who knows a function's address can call it, so each function has to check who sent the request.
- The Policies view is not the whole picture. Lovable says the view "on its own is not a full report": it shows the policies, not the grants underneath them, nor how database functions run.
- Sign-up is part of access. If sign-up is open and your policies only ask for a signed-in user, a stranger is one form away from the data. The Users view has a Disable sign-up setting for internal apps.
- Secrets. Keys for Stripe, an AI provider or email belong in the Secrets view, used from server code. A secret in a browser variable reaches every visitor.
The agent's permissions on your data
On Lovable Cloud the same agent that writes your pages also holds your database. The built-in backend docs list what it may do without asking, under Agent permissions.
| Permission | What it allows | Default |
|---|---|---|
| Modify database | Schema and policy changes through SQL migrations | Always allow |
| Change data | Add, update or delete data in your tables | Always allow |
| Configure auth | Change authentication settings, such as sign-up policies | Always allow |
| Execute backward incompatible database migrations | Drop or rename a table or column | Never allow |
How to check a Lovable Cloud app
- 1
Read the policies, table by table
Go to More, Database, Manage, Policies. For each table that holds personal data, look at the Applies to column and expand the rule. An
anonpolicy on a private table, or anauthenticatedpolicy with no condition on the owner, is a finding. - 2
Ask the question Lovable suggests
In the project chat: "Which of my tables can people who aren't signed in read or change?" Then ask whether your server code checks permissions. Treat the answers as leads to verify.
- 3
Run the Deep scan
The Quick scan at publish does not read your code. Open the Security view and run the Deep scan, which also checks that server code honours the ownership rules of the database.
- 4
Look at storage and sign-up
In More, Storage, every bucket card should read Private unless its files are meant for everyone. In More, Users, Settings, check whether sign-up should be open, and turn on the Password HIBP check under Email.
- 5
Test the published app from outside
Open it signed out in a private window, then with two test accounts. The second account must not see the first one's records. Then replay one request without a session, as below.
# On your own app only.
# 1. Open the published app signed out, with the browser's Network tab open.
# 2. Find a request to your backend address that returns rows.
# 3. Right-click it, choose Copy as cURL, and run it in a terminal.
# It carries the publishable key and no user session.
# The request looks like this (address and key come from your own app):
curl -s "https://YOUR-BACKEND-ADDRESS/rest/v1/orders?select=*&limit=1" \
-H "apikey: YOUR_PUBLISHABLE_KEY"
# Now change the table name to one that holds private data.
# An empty list [] or an error is what you want. A row is a leak.The SQL queries that list tables without RLS and policies that let everyone through are in the Lovable security guide. They run in the SQL editor of the built-in backend.
If you connect your own Supabase instead
Teams choose their own project to keep the Supabase dashboard, their billing and direct access to the database. The rules question is identical, and three things are added to your side.
- The Supabase account. Its password, its two-factor setting and its access tokens now protect your data. See Supabase security.
- Shared projects. Lovable warns that several Lovable projects connected to one Supabase project read and write the same data and overwrite each other's secrets. Design the policies with that in mind.
- Fewer built-in aids. Signed-in browser testing, auth configuration from the chat and password rotation by Lovable work on the built-in backend only. Lovable's docs tell you to verify the policies yourself in the Supabase dashboard before going live.
Where Keybrum fits, and where it does not
Keybrum is the automated pentest we build for web apps made with AI. It does not test Lovable's platform or the infrastructure of Lovable Cloud: that belongs to Lovable. It does not read your project's code inside Lovable either. Lovable's own scans do that, and Lovable also offers pentests by Aikido as an optional integration.
Keybrum works from outside, on the published app, for an owner who has proved ownership. It takes the backend address and the public key from your JavaScript, as a stranger would, and tries the tables your app names: read, insert and update, signed out and as a freshly signed-up account. It calls database functions, lists storage buckets, subscribes to realtime channels, and checks whether a second account can open the first one's records. It looks for secret keys in the bundle and for edge functions or AI routes that answer anyone. Delete access is never tested, and write tests are built so that nothing is written.
Each finding comes with the request that worked and a fix prompt to paste into Lovable. A one-time report costs €49. Plans start at €29 a month, excluding VAT, and attack again on every deploy, so a policy loosened by a prompt next week shows up next week.
Questions
What is Lovable Cloud?
It is Lovable's built-in backend: a managed PostgreSQL database, authentication, file storage, realtime and edge functions, enabled by default and paid with Lovable credits. The docs say it uses Supabase's open-source foundation. You manage it from the Database, Users and Storage views inside Lovable.
Is Lovable Cloud the same as Supabase?
It is built on Supabase's open-source foundation and gives the same kinds of features, but it is hosted and managed by Lovable. You do not get a Supabase account or the Supabase dashboard. If you want those, connect your own Supabase project instead.
Is Lovable Cloud secure?
The infrastructure is managed, backups are daily and public buckets are blocked by default. Whether your app leaks depends on your row level security policies and your server code, as on any Supabase-style backend. Lovable's docs say you are responsible for meeting the security needs of your use case.
Do I still need RLS with Lovable Cloud?
Yes. Your app's pages call the database from the browser with a publishable key that anyone can copy. RLS policies are the only thing between that key and your rows. Lovable writes policies when it builds features, and you should read them.
Can I move from Lovable Cloud to my own Supabase?
Not in one step. You export the database and restore it into your Supabase project, move storage files and code, and set up authentication, secrets and external services again. Migration from Supabase to the built-in backend is not supported.
Can Lovable's agent delete my data?
By default the Change data permission is on Always allow, so the agent can add, update or delete rows when a request leads there. Dropping or renaming a table or column is set to Never allow. You can set both to Ask each time in Agent permissions.
Sources
- 1.Built-in backend, Lovable Documentation
- 2.Control who can access your app's data, Lovable Documentation
- 3.Connect your own Supabase project, Lovable Documentation
- 4.Security, Lovable Documentation
- 5.Storage, Lovable Documentation
- 6.Database backups, Lovable Documentation
- 7.Edge functions, Lovable Documentation
- 8.CVE-2025-48757, NIST National Vulnerability Database