u/carolmonroe_

You can finally export your data and remove Lovable Cloud, it just launched
▲ 94 r/Supabase+1 crossposts

You can finally export your data and remove Lovable Cloud, it just launched

Fresh out of the oven, so heads up if you don't see it in your account yet. Thank you Lovable team for shipping this one.

Some context on why I'm excited: over the last months I've been creating guides, skills and workflows to help builders migrate from Lovable Cloud to their own Supabase, because until today there was no official way out. Your data was basically locked in, and every migration was a hand-crafted workaround. Now there's an official path, and it's simple.

Step 1: Export your database

Go to Stack > Lovable Cloud > Advanced settings > Export data, then select "Export" in the Database card (screenshots below). You'll get a temporary download link by email. Limits: 5 GB max, one export every 24 hours.

What's actually in the file

It's a full Postgres backup (.backup file, pg_dump custom format, ready for pg_restore). And it's surprisingly complete:

  • Full schema: tables, indexes, sequences, extensions
  • All your data
  • All RLS policies
  • Database functions and triggers
  • Your users: the full auth schema, including password hashes, so your users won't need to reset passwords

One warning: because it includes password hashes and user PII, treat this file as sensitive.

Step 2: Remove Lovable Cloud

Before connecting your own Supabase, disconnect the old backend: Stack > Lovable Cloud > Advanced settings > Remove Lovable Cloud.

Just make sure you have everything downloaded FIRST: your database export and your storage files (user uploads and images live in the Storage section and are not part of the database export). Once Cloud is removed, that's your only copy.

Cloud used to be permanent once enabled, so having this button at all is a big shift. And if you're not ready to fully leave, you can now pause your Cloud instance instead (screenshots below).

https://preview.redd.it/trdhbhmwi1bh1.png?width=1198&format=png&auto=webp&s=cd9f2491379b22597b517297075e908eed7d9d9d

Step 3: Connect your own Supabase project

Create your Supabase project, then connect it through Connectors: pick the Supabase connector, authorize it, go back to your Lovable project and add it. This is the native integration, so your app talks to your own Supabase from here on.

If you want to double-check everything is wired correctly, leave Lovable a prompt like:

>"Review my Supabase connection: confirm the app is pointing to my new Supabase project, check that auth, database queries, storage and edge functions all work against it, and list anything still referencing the old backend. Don't change anything yet, just report what you find."

Step 4: Move the rest over

Restore the backup into your new Supabase with pg_restore, then cover the three things that don't come in the file (by design, they don't live in the database):

  • Edge functions: they're in your repo under supabase/functions
  • Storage files: re-upload the ones you downloaded in step 2
  • Secrets and API keys: re-set them in your new project

You can finish all of this with the MCP (I'll write about that soon), but honestly, today this whole flow is easier and more intuitive than it's ever been.

Why this actually matters

This changes how I think about Lovable Cloud, and probably how you should too.

Lovable Cloud is genuinely good, and not just for small projects. Auth, database, storage, edge functions, all working out of the box with zero keys to manage. The thing that made people hesitate was never the product, it was the lock-in: once you enabled Cloud, there was no official way out. That meant choosing it felt like a permanent decision, so a lot of us defaulted to our own Supabase "just in case."

That trade-off is gone. If your project outgrows Cloud, or you need full dashboard access, or your team wants total control, you export, remove, connect, restore, done.

Honestly, I might use Lovable Cloud MORE now, not less. Knowing I can migrate later in an easy, efficient way removes the main reason I was cautious about it. Start fast on Cloud, move when (and if) you actually need to.

What's next

I tested this flow end to end, and I'm working on a skill and plugins to make the whole move even smoother, everything the export doesn't cover, automated. That plus the updated migration guide will be on my site soon, I'll share them here when they're live.

Docs: https://docs.lovable.dev/integrations/cloud#export-lovable-cloud-data

reddit.com
u/carolmonroe_ — 2 days ago
▲ 1 r/Supabase+1 crossposts

Where to Find Lovable Cloud and Supabase in Your Lovable Project

Everything is now under the "More" button on the right side of the top bar. Click it and you will see the Cloud section in the sidebar with all your backend services: Database, Users, Storage, Edge functions, SQL editor, Logs, and more.

https://preview.redd.it/mdq7vzjlvk3h1.png?width=347&format=png&auto=webp&s=ec95abe0584e7ce93bfaf425594c5f10e5ae920b

https://preview.redd.it/uivguqrnvk3h1.png?width=372&format=png&auto=webp&s=6babd22c12bc3f8b9b0f195b9ab5d53d7045c0cb

https://preview.redd.it/hxau1ooovk3h1.png?width=1213&format=png&auto=webp&s=a41298abfd646c35b20b9048259b23a6910d5b11

reddit.com
u/carolmonroe_ — 1 month ago

migrating from Lovable Cloud to your own Supabase is actually easy now

if you're building on Lovable and using Lovable Cloud, and you've been wanting to use more of Supabase, the dashboard, custom auth providers, email templates, edge functions, staging environments, you can now migrate without losing anything.

Lovable just shipped their MCP server and it changes how this works. you can query your Cloud database directly, including auth.users with original password hashes. that means your users keep their exact login credentials after migration. no password resets, no "please create a new account."

for a long time we were finding workarounds, edge function exports, REST API calls, manual schema recreation. they worked but they had gaps. now you can do the whole thing in one session.

this guide is built from helping with a lot of migrations over the past year as part of SupaSquad. the patterns, the mistakes, the order of operations, it's all stuff that came up over and over. I just put it all in one place now that the MCP makes the full process possible.

how it works:

  1. scan your Lovable Cloud database via the MCP (schema, data, auth users, storage URLs)
  2. create a new Supabase project via the Supabase MCP
  3. apply schema, enums first, then tables in FK order, then RLS policies
  4. migrate auth users with original bcrypt hashes (this goes BEFORE data because profiles has a FK to auth.users)
  5. insert data in dependency order
  6. migrate storage files and rewrite URLs in the database
  7. deploy edge functions
  8. create a new Lovable project, connect Supabase + GitHub, push the frontend code
  9. run a full audit, row counts, zero old URLs, login test with original credentials

9 phases, 40 steps, only 2 manual clicks (connecting Supabase and GitHub in the Lovable dashboard). everything else is automated through the MCPs.

the guide also covers what NOT to do (I made every mistake so you don't have to) and has a "do you actually need to migrate?" section because honestly, Lovable Cloud works well for a lot of projects. no reason to migrate if it's meeting your needs.

I also built a Claude Code skill that automates most of it.

guide: https://carolmonroe.com/blog/lovable-cloud-mcp-migration skill: https://github.com/CarolMonroe22/lovable-cloud-to-supabase-migration

hope it helps if you've been stuck on this or just want more control over your setup.

u/carolmonroe_ — 2 months ago