Leaving Lovable is possible, and Lovable documents how. Its hosting and ownership overview says "you are never locked in": the code can live in your own Git repository on every plan, and the built-in backend can move to managed or self-hosted Supabase. The front end is the easy part. The backend, with its user accounts, files, secrets and scheduled jobs, is where migrations go wrong.
This guide covers the order we would follow for a real business app, the numbers that limit each step, and the cases where staying on Lovable is the better call. If you are staying and simply want to go live properly, read taking a Lovable app to production instead. Everything below was checked against official documentation on 20 November 2026.
- Git sync to GitHub, GitLab or Bitbucket is on every Lovable plan; a .zip code download needs a paid plan.
- Lovable Cloud's database export includes users' password hashes, so people keep their passwords, but everyone has to sign in again.
- The export leaves out storage files, edge function code, secrets and sign-in provider settings; you move those by hand.
- Exports are capped at a 5 GB file, databases up to 15 GB, and one export every 24 hours.
- Lower your DNS TTL a week ahead, rehearse the move on a copy, and keep Lovable running until the new setup is proven.
Should you move your app off Lovable at all?
Only if you have a concrete reason. For most small teams that build by prompting, Lovable's hosting and built-in backend are a sound production setup, and a move adds work you then own for good: builds, environment variables, logs, backups and uptime. Lovable's guide to hosting outside Lovable is blunt that it cannot monitor or debug infrastructure it does not control.
Good reasons to move include a data residency rule, a developer team that needs its own pipeline and staging, direct database access, or a dependency on a service Lovable does not offer. Supabase's Lovable Cloud troubleshooting page confirms that on Lovable Cloud the service role key is not accessible and external database connections are not supported, which rules out most reporting tools.
| Question | Stay on Lovable if | Move if |
|---|---|---|
| Who maintains the app? | Non-developers, building by prompt | Developers who want pull requests, CI and staging |
| Where must data live? | A Europe region is enough | You need a specific country, such as London |
| Do you need direct database access? | No, the in-app Database view is enough | Yes, for BI tools, scripts or your own backups |
| Do you use Lovable AI or connectors? | Yes, heavily | No, or you will budget to replace them |
| How big is the database? | Any size | Under 15 GB, or you have agreed a route with Lovable support |
| Is there a developer to own hosting? | No | Yes, with time for monitoring and incidents |
Cost rarely decides it. Lovable Pro starts at $25 a month with hosting included. Moving usually means Supabase Pro from $25 a month plus a host, and you still pay Lovable if you keep building there.
Lowest published tier of each plan; usage charges are extra.
| Plan | From, per month |
|---|---|
| Lovable Pro (hosting included) | |
| Lovable Business | |
| Supabase Pro project | |
| Vercel Pro, per developer seat |
Sources: Lovable, Subscription plans, checked November 2026; Supabase, Pricing, checked November 2026; Vercel, Hobby plan, checked November 2026
There is also a middle path: move only the front end to your own host and keep Lovable Cloud, still building in Lovable.
Do I own my Lovable code?
Yes, in practice: Git sync puts a copy in a repository you own, and it is available on every plan, including Free. Turn it on before you plan anything else.
Lovable's GitHub integration docs describe two-way sync on one branch at a time, usually main, into a repository that is private by default. Do not delete the repository, because that stops the sync. If you disconnect, the repository stays on GitHub but later Lovable changes stay only in Lovable. Paid plans can also download a .zip snapshot of the codebase.
Before going further, clone the repository and run the app on your own machine. If the repo only has bun.lock, use Bun or commit a package-lock.json, as Lovable advises.
What moves easily off Lovable, and what is hard?
The front-end code and the database structure move easily through Git. Data, user accounts, files, secrets, sign-in settings and anything that runs through Lovable's own services take manual work.
Check which stack you have first. Projects created from 13 May 2026 use TanStack Start, which renders on the server, so the host must run server code. Older projects use React and Vite and build to static files in dist/, which any static host can serve as long as unknown routes fall back to index.html. Look for @tanstack/react-start in package.json.
| Part of the app | Git sync | Database export |
|---|---|---|
| Front-end and server code | Yes | No |
| Schema, RLS policies and triggers (migration files) | Yes | Yes |
| Table data | No | Yes |
| User accounts and password hashes | No | Yes |
| Storage files | No | No |
| Secrets and API keys | No | No |
| Sign-in provider settings | No | No |
| Lovable connectors and AI gateway | No | No |
Sources: Lovable, Database backups, 2026; Lovable, Deploying and hosting outside Lovable, 2026
The bottom four rows are the real work. Lovable lists app connectors, AI features that run through its AI gateway, and chat connectors among the things that break or need replacing. AI features need your own provider account and keys. Scheduled jobs must be recreated and never run on both backends at once. Moving PostgreSQL alone does not move auth, storage, realtime or edge functions, which is why Lovable's only supported backend destinations are managed or self-hosted Supabase.
What order should a Lovable migration follow?
Code first, backend rehearsal second, front-end hosting third, and the domain last. Nothing customer-facing changes until the final step, so you can stop at any point.
- Turn on Git sync and run the app locally from a clone
- List everything that calls Lovable: Cloud, connectors, AI features, scheduled jobs
- Create a Supabase project in your chosen region and apply the migrations
- Rehearse: export, restore, copy files, set secrets, deploy edge functions
- Deploy the front end to the new host on a temporary address and test
- Lower DNS TTL a week ahead and add the new auth redirect URLs
- Pause writes, take the final export, restore and switch DNS
- Monitor, keep Lovable as the fallback, then unpublish and remove Cloud
Lovable advises timing the export and restore on a test run, because writes are paused for that long at cutover, and only one export is allowed every 24 hours.
How do you move Lovable Cloud to your own Supabase project?
You export the database from Lovable, restore it into a new Supabase project with pg_restore, then rebuild what the export leaves out. There is no one-click transfer; Supabase states there is no automated way to move a Lovable Cloud project into your own account.
Lovable's database backups page sets out the export. Under More, Database, Manage, Settings, choose Export data. You get a compressed PostgreSQL .backup archive for PostgreSQL 16 or newer tools, saved to the project's own storage, so download it before removing anything.
- 15 GB is the largest database storage that can be exported
- 5 GB is the maximum size of the export file
- 1 export can be requested every 24 hours
- About 14 days of daily backups are kept for restores inside Lovable
On the Supabase side, Lovable's steps are: create the project and note its URL, project ID and key; apply supabase/migrations/ in order; restore the data with pg_restore, without adding --clean until you understand what it drops; then copy storage files, set secrets, deploy edge functions with npx supabase functions deploy and recreate scheduled jobs. Supabase's backup and restore guide adds a few: re-enable extensions, database webhooks and realtime publications.
What happens to users' passwords and sessions?
Passwords survive. Lovable says the export includes users' accounts and password hashes, and Supabase's guide to migrating auth users between projects confirms that users then do not need to reset their passwords. Sessions do not survive. Tokens are signed with a project-specific secret, so everyone who is signed in will have to sign in again on the new backend. Warn users before the switch.
Social sign-in needs more care. Lovable notes that managed OAuth configuration only works on its built-in backend, so Google or Apple sign-in must be set up with your own credentials in the new Supabase project, with the new domain added to each provider's allowed redirect URLs.
Which region should a UK business choose?
Lovable Cloud offers three broad regions: Americas, Europe and Asia Pacific. Your own Supabase project can sit in a specific one; the Supabase regions list includes West Europe (London), eu-west-2. If data location is your reason to move, choose London, update your privacy notice, and check the host too: Vercel runs functions in Washington, D.C. (iad1) by default for new projects. Our vibe-coded app security checklist covers RLS testing once the data has landed.
Where should you host a Lovable app: Vercel, Netlify or Cloudflare?
Any of the three works. Lovable's guide says the Nitro build used by TanStack Start apps detects Vercel, Netlify and Cloudflare Pages automatically, building with npm run build on Node.js 22. For Netlify and Cloudflare Pages, set the output directory to dist.
On Vercel, set the function region next to your Supabase project; its region settings include London (lhr1). Netlify's pricing runs on credits, with paid plans from $9 a month. The free tiers all have limits worth knowing:
- 100 GB of Fast Data Transfer and 1,000,000 function invocations a month on Vercel Hobby
- 100,000 requests a day, with 10 ms of CPU per request, on Cloudflare Workers Free
- 500 MB database on Supabase Free, with projects paused after 1 week of inactivity and no automatic backups
Sources: Vercel, Hobby plan, checked November 2026; Cloudflare, Workers limits, checked November 2026; Supabase, Pricing, checked November 2026
Which environment variables does the new host need?
Lovable lists the browser variables VITE_SUPABASE_URL, VITE_SUPABASE_PUBLISHABLE_KEY and VITE_SUPABASE_PROJECT_ID, plus SUPABASE_URL and SUPABASE_PUBLISHABLE_KEY for TanStack Start server code, and any secrets your server functions read. VITE_ values are baked in at build time, so rebuild after changing them. Never give a secret key a VITE_ prefix, because that ships it to every browser. Payment webhooks need new endpoints too; see fixing Stripe webhooks in Lovable and Supabase.
How do you switch the domain without losing sign-ins or search rankings?
Keep every URL the same, prepare the new host on a temporary address, lower the DNS TTL a week before, and only then point the domain at the new host. If the URLs do not change, search engines treat it as a hosting move, not a site move.
Google's guide to moving hosting without URL changes recommends a conservative low TTL of a few hours, set at least a week in advance. Test on a temporary hostname with noindex, remove that block before the switch, and keep the old host running until its logs show no traffic. Crawl rate often dips briefly after the move, then recovers.
- 1 week before the move is when Google suggests lowering your DNS TTL
- A few hours is the conservative low TTL Google suggests for the move
- 300 seconds is the minimum TTL Lovable accepts on DNS records
- 302 is the temporary redirect Lovable uses between connected domains, not a 301
Sources: Google Search Central, Site moves without URL changes, checked November 2026; Lovable, Custom domains, checked November 2026
If any URLs do change, add server-side permanent redirects from each old URL to its new one. Google's site move guidance says to keep them for at least a year. Two Lovable details matter here. The lovable.app address stays with Lovable and keeps serving the last published version, so unpublish it once you have moved, or it competes with your real domain. And Lovable's Publish button only ever publishes to Lovable hosting, so after the switch your releases come from Git pushes to the new host. An SEO specialist can check canonical tags, the sitemap and Search Console before and after.
Sign-ins break on cutover day more often than anything else. Add the production domain to the Supabase project's auth redirect URLs and to every OAuth provider before you switch DNS, then test sign-up, sign-in, password reset and sign-out on the live domain straight away.
What goes on the cutover checklist, and how do you roll back?
Cut over in a quiet window, with one owner and this list:
- Announce a short maintenance window and warn users they will need to sign in again.
- Pause writes, take the final export, download it and copy any storage files changed since the rehearsal.
- Restore into Supabase and compare row counts on the main tables.
- Switch the production environment variables, rebuild and deploy.
- Point DNS at the new host and confirm the SSL certificate is live.
- Test a deep link, a server-rendered page, sign-in, uploads, payments and emails.
- Turn on scheduled jobs on the new backend only, and check they are off on the old one.
- Search the code for leftover calls to Lovable, such as connectors, AI calls and the old backend URL.
Rollback is simple only if Lovable is left intact. Removing the Lovable Cloud database deletes its backups, user accounts, files and your saved export, and cannot be undone, so wait until the new setup has run cleanly. With a low TTL, rolling back means pointing DNS back at Lovable, but data written after cutover exists only in the new backend, so set a rollback deadline in advance. Finally, cancel or downgrade the Lovable plan; moving does not cancel it.
If the app has grown messy over hundreds of prompts, a migration is a natural point to ask whether to fix or rebuild it, and our guide to what it costs to fix a vibe-coded app sets out typical budgets. Still choosing tools for a new build? See Lovable vs Bolt vs Replit vs Cursor. A Lovable developer can run the rehearsal and cutover with you, and a security audit is worth doing on the new backend before you take payments.
Frequently asked questions
Can I export my app from Lovable?
Yes. Git sync copies the code to your own GitHub, GitLab or Bitbucket repository on every plan, and paid plans can also download a zip of the codebase. Lovable Cloud data is exported separately from the project's database settings as a PostgreSQL backup file, and storage files are downloaded on their own.
Do I own the code Lovable writes for my app?
In practice, yes. With Git sync turned on, every change is committed to a repository in your own Git account, private by default, and you can build and deploy it anywhere. Lovable describes itself as built so you are never locked in. Check your contract terms if ownership matters legally.
Will my users have to reset their passwords if I leave Lovable Cloud?
No. Lovable's database export includes user accounts and password hashes, and restoring them into Supabase keeps passwords working. Sessions do not carry over, so everyone who is signed in must sign in again. Social sign-in such as Google needs your own OAuth credentials and the new redirect URLs.
Can I host a Lovable app on Vercel or Netlify?
Yes. Lovable's own guide says Vercel, Netlify and Cloudflare Pages are detected automatically by the Nitro build used in newer TanStack Start apps. Older React and Vite apps build to static files that any static host can serve. Set the Supabase environment variables on the host and rebuild after changing them.
Can I move just the front end and keep Lovable Cloud?
Yes. Lovable documents this hybrid setup: the front end deploys from your Git repository to a host such as Vercel, while the database and sign-in stay on Lovable Cloud and you keep building in Lovable. The Publish button still only publishes to Lovable hosting, so releases come from Git pushes.
How long does it take to migrate off Lovable?
It depends on how much of the app runs on Lovable Cloud and Lovable services. A front-end-only move is the quickest. A full backend move needs a timed rehearsal, testing on a copy and a planned cutover, and Google advises lowering DNS TTL at least a week ahead, so plan for weeks rather than days.
Is my data safer outside Lovable?
Not automatically. Moving gives you control over region, backups and database access, but you also take on security settings, monitoring and incident response. Common weaknesses in vibe-coded apps, such as missing Row Level Security and exposed keys, follow the app wherever it is hosted. Test RLS after the move.
Sources
Checked on 20 November 2026. Product features and figures change quickly, so check the current source before you rely on a detail.
- Lovable documentation: Deploying and hosting outside Lovable
- Lovable documentation: Database backups and export
- Lovable documentation: GitHub integration
- Lovable documentation: Subscription plans
- Lovable documentation: Custom domains
- Supabase documentation: Migrating auth users between projects
- Supabase: Pricing
- Vercel documentation: Hobby plan
- Cloudflare documentation: Workers limits
- Google Search Central: Site moves without URL changes
Planning to move your app off Lovable?
Circlemount works as your Lovable developer: we plan the migration, rehearse it on a copy, move Lovable Cloud to your own Supabase project and handle the cutover, or tell you honestly if staying put is the better choice. The initial app assessment is free, project work starts from £1,000 + VAT, and ongoing support plans start from £125 a month + VAT. Join the Circle to book yours.





