Lovable Cloud vs Supabase: when to switch, and how
Lovable Cloud runs on Supabase, managed and billed by Lovable. Your own Supabase project gives you the same database, sign-in, storage and functions, plus the full dashboard, direct database access and a separate Supabase bill. Most apps should stay on Lovable Cloud until they hit a specific limit, because Lovable won’t switch a project for you: moving is a manual migration of data, users, files, secrets and integrations.
What Lovable Cloud actually is
Lovable calls it the built-in backend. Its docs say it “utilizes Supabase’s open-source foundation”: a Postgres database, authentication, file storage, realtime updates and edge functions (server code that runs on demand). Lovable manages it for you, and you don’t get a Supabase account or dashboard for it.
Cloud is billed in Lovable credits, from the same balance you build with. Each Free, Pro and Business workspace gets a monthly Cloud grant, then running the app draws on general credits. Usage is split into Database, Network, Storage, Compute and Realtime. If credits run out, apps on Cloud pause. Our Lovable Cloud pricing guide covers what drives that bill.
Connecting your own Supabase project is the alternative. You pick one per project, and Lovable’s docs are explicit that there’s no automatic migration in either direction.
What you can and can’t reach on Lovable Cloud
| Lovable Cloud | Your own Supabase | |
|---|---|---|
| Dashboard | Lovable’s Database, Users, Storage, Edge functions, Jobs, Secrets, Logs and Usage views | The full Supabase dashboard |
| SQL | A SQL editor inside Lovable, and Lovable’s API and MCP server | SQL editor, psql, any Postgres client |
| Connection string | Not shown. Lovable manages the database password and never displays it | Yours |
| Backups | Daily, about 14 days kept, no point-in-time restore | Daily (7 days on Pro, 14 on Team), point-in-time recovery as an add-on |
| Database size | Tiny to X-Large on paid plans | Micro up to 16XL and beyond |
| Extensions | A fixed list of 11, plus the preinstalled ones | Supabase’s full list |
| Logs | Searchable. Quick ranges go back 5 days, or pick exact start and end times | Supabase logs, plus log drains |
| Region | Locked when the backend is created | Chosen per project |
Secrets on Cloud are write-only: once saved, Lovable never shows the value again. The service role key and database URL exist inside your edge functions’ environment, but you can’t copy them out.
Lovable Cloud vs Supabase: which should you choose?
| Stay on Lovable Cloud if | Move to your own Supabase if | |
|---|---|---|
| Cost visibility | Per-project credits by category are enough | You want itemized per-unit billing and a spend cap. The cap is Pro-only and doesn’t cover compute hours |
| Control | Lovable’s views and SQL editor cover what you do | You need a connection string, an extension off Lovable’s list, point-in-time recovery or a region change |
| Team access | Everyone works through Lovable | Engineers, analysts or BI tools need direct access with their own roles |
| Compliance | SOC 2 Type II and ISO 27001 are enough | You handle health data. Lovable says it isn’t HIPAA-compliant and doesn’t sign BAAs. Supabase offers HIPAA on Team and above as a paid add-on with a signed BAA |
| Scale | X-Large covers your load after fixing slow queries | You need bigger compute than Lovable offers |
| Lock-in | You’re happy using Lovable AI, connectors and in-editor auth settings | You want every key and setting in an account you own |
Moving also gives things up. Lovable’s docs list what needs the built-in backend: the in-editor backend views, managed backups and resizing, configuring sign-in from the chat, auth emails from your own domain, signed-in browser testing, sensitive data scanning, and built-in payments on older React + Vite apps.
What it’s like to work on a Lovable Cloud app
We’re the engineering team for a media delivery app that runs on Lovable Cloud. Day to day, a few things work differently from a Supabase project you own:
- Pushing to GitHub doesn’t apply migrations. We write each migration with read-only pre-checks, verification queries and a rollback. The founder runs it in Lovable’s SQL editor, and the file in the repo records the change.
- Merging doesn’t deploy edge functions. Once Lovable has synced the commit, someone asks Lovable’s chat to deploy the named function. Front-end changes go live on the next Publish.
- We inspect it through Lovable’s MCP server, checking which commit Lovable has synced and running read-only queries. There’s no Supabase dashboard to log into.
- The schema history lives in two folders: hundreds of older files in
supabase/migrations/and newer ones indrizzle/migrations/. Lovable’s docs confirm it now records changes with Drizzle, and earlier files stay in the Supabase folder.
None of this stopped us fixing the app’s costs. We cut its Realtime line, the largest part of the bill, by about 90% without moving. Supabase also bills Realtime per message, counting one for every client listening to a change, so switching providers wouldn’t have shrunk it. The same goes for limits: a ZIP-building function ran out of memory on Cloud, and Supabase documents the same 256 MB cap for its own edge functions.
How the move works, step by step
These steps follow Lovable’s migration guide and Supabase’s docs, with what to watch for from running a Cloud app in production.
- Take an inventory. List secret names, edge functions, scheduled jobs, and every outside service that calls your backend’s URL.
- Create the Supabase project on a plan that fits. Supabase’s Free plan allows 100 edge functions per project. The app we work on has more than twice that.
- Rebuild the schema by applying the migration files in order, from both folders if you have both. Because changes can also reach production through the SQL editor, compare the result with the schema in your export before trusting it.
- Export the database from More → Database → Manage → Settings. It’s a compressed Postgres archive you load with
pg_restore, and it needs a build with zstd support. Lovable exports databases up to 15 GB, with an export file of at most 5 GB, and allows one export every 24 hours, so take your rehearsal export at least a day before the cutover. - Reconfigure sign-in: enable each provider and update OAuth redirect URLs. The export doesn’t include sign-in provider settings.
- Copy storage files. The export covers the database only.
- Re-enter secrets and deploy functions with the Supabase CLI. Recreate scheduled jobs.
- Replace Lovable AI and app connectors. Lovable’s docs say they run through Lovable and need your own accounts once the backend moves.
- Point a test deployment at the new project and test sign-in, reads, writes, uploads, functions and jobs.
- Cut over: pause writes, take the final export, and restore the data you need from it. Your migrations already created the schema, so list the archive with
pg_restore --listand restore selectively. Then copy changed files, update.envandsupabase/config.tomlin Lovable, then publish.
The gotchas that break apps
- Users keep their passwords, but not their sessions. The export includes password hashes. The new project signs tokens with its own keys, so everyone signs in again.
- Secrets can’t be exported. Cloud never shows stored values, so get each key again from the service that issued it.
- Hard-coded URLs. Webhooks from payment and email providers, OAuth callbacks and scheduled jobs all contain the old project’s address. On the app we work on, more than a dozen functions are called by outside services, and its scheduled jobs call functions by their full URL.
- Jobs running twice. Restored jobs can keep calling the old backend, or both copies can run. Lovable’s guide says to coordinate switching them over.
- Vault secrets. Supabase Vault’s encryption key lives outside the database, so restored Vault secrets can’t be decrypted without it. Between two projects you own you can copy the key over. From Lovable Cloud you can’t reach it, so plan to re-enter those values.
- Mobile apps. Every installed build has the backend address baked in. On the app we work on, phones running older builds were still connecting with old code after newer versions shipped. Plan a forced update or keep the old backend running while old builds are still in use.
- Downtime. Anything written after your final export is lost unless you pause writes. Time the export and restore during your test run, because that sets the length of the pause.
- Don’t delete too early. Removing the Cloud database deletes its backups, and the exports saved to its storage too.
What changes in the Lovable editor
Lovable’s docs say that once .env and supabase/config.toml point at the new project, the preview and the next publish use it, and you can keep building in Lovable. What they don’t spell out is how a former Cloud project becomes a connected Supabase project that Lovable deploys to: the connect option only appears on projects without a backend. Until Lovable confirms that for your project, plan to apply migrations and deploy functions yourself.
How to decide for your own app
- Find your biggest cost line in Plans & credit usage. If that’s your reason to move, fix it first.
- Name the requirement Cloud can’t meet: HIPAA, direct database access, an extension, point-in-time recovery, a region.
- Check your database size against Lovable’s 15 GB export limit.
- Count everything that knows your backend’s URL, including installed mobile builds.
If you’re weighing a move, our Lovable rescue starts by working out whether the problem is the platform or the app.
