Lovable Cloud security: what the built-in backend changes, and what stays yours

Lovable Cloud is the built-in backend of Lovable: a managed PostgreSQL database, sign-in, file storage, realtime and edge functions, built on Supabase's open-source foundation and enabled by default. Lovable runs the infrastructure. The access rules stay yours: your app reads the database from the browser with a public key, so row level security policies decide what a stranger gets, as with your own Supabase project.

The team behind Keybrum's attacksUpdated 11 min read

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 authenticated gives 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.
Built-in backend, Lovable Documentation

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 CloudYour own SupabaseFor security
Account and billingNone extra. Lovable creditsYour Supabase account and planOne login less to protect with Cloud. With your own project, the Supabase account and its access token are yours to guard
Where you manage itDatabase, Users and Storage views inside LovableThe Supabase dashboardCloud has no Supabase dashboard. You read policies in a read-only view and change them through the chat or the SQL editor
Auth settingsConfigured through LovableConfigured in SupabaseSame settings to check either way: sign-up open or closed, email confirmation, leaked-password check
Backups and passwordDaily backups kept roughly 14 days. Lovable rotates the database password on requestManaged by you in SupabaseCloud gives you a restore without setup. Rotation by Lovable does not cover your own project
Lovable's checksDatabase review at publish, a review dialog on critical findings, signed-in browser testingThe database review runs. Signed-in testing does notMore of Lovable's own tooling applies on Cloud
Access rulesYour RLS policiesYour RLS policiesNo difference. This is where apps leak
First three columns from Lovable's Supabase integration and built-in backend docs, November 2026.

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.

RoleWho it isWhat your policies do
anonAnyone with the publishable key, signed outApply. A policy open to anon is open to the internet
authenticatedAnyone who signed up and signed inApply. A policy that checks only this role gives every user the same rows
service_roleYour server code with the admin clientDo 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.
Control who can access your app's data, Lovable Documentation

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.

PermissionWhat it allowsDefault
Modify databaseSchema and policy changes through SQL migrationsAlways allow
Change dataAdd, update or delete data in your tablesAlways allow
Configure authChange authentication settings, such as sign-up policiesAlways allow
Execute backward incompatible database migrationsDrop or rename a table or columnNever allow
Defaults from the built-in backend documentation. Change them in Account settings, Preferences, Agent permissions.

How to check a Lovable Cloud app

  1. 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 anon policy on a private table, or an authenticated policy with no condition on the owner, is a finding.

  2. 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. 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. 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. 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.

bash
# 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 path shown is the Supabase-style one. Use the exact address your own app calls. The key is public by design, so this is what any visitor can do.

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. 1.Built-in backend, Lovable Documentation
  2. 2.Control who can access your app's data, Lovable Documentation
  3. 3.Connect your own Supabase project, Lovable Documentation
  4. 4.Security, Lovable Documentation
  5. 5.Storage, Lovable Documentation
  6. 6.Database backups, Lovable Documentation
  7. 7.Edge functions, Lovable Documentation
  8. 8.CVE-2025-48757, NIST National Vulnerability Database

Your app is public. So are its mistakes.

Check what any attacker can already see in it, free, in ten seconds. The full attack, with proof and fixes: €49 once, or €29 a month on a plan.

or continue with Google or GitHub