How to Move Your Lovable Project to Floot (2026 Guide)

You built something real on Lovable, and now the bill doesn't fit the project. Maybe you ran out of credits mid-feature one too many times, maybe you want your AI assistant and your app builder to be the same subscription, maybe you just want a real backend without wiring up Supabase. Whatever pushed you here, the good news: your Lovable project is portable, and moving it to Floot is a weekend job, not a rebuild from scratch.

The short version of the migration, before we unpack each step:

1. Export your code from Lovable via its GitHub sync.
2. Import the project into Floot.
3. Rebuild the backend pieces on Floot's built-in database, auth, and storage.
4. Move your data over.
5. Point your domain at the new site and set up redirects.
6. Test everything, then close the old tab for good.

One honest note before we start: your frontend moves cleanly, because it's ordinary React code. The backend is where migrations earn their reputation, and we'll spend the most time there.

Why people move from Lovable to Floot

Three reasons come up over and over.

The first is the meter. Lovable sells AI credits on top of whatever you already pay for an AI assistant, so every feature, fix, and "actually, make it blue" draws down a balance. Floot flips that: connect Floot to Claude or ChatGPT over MCP and the AI runs on the plan you already pay for, with zero credits on top. We've written about that double-payment problem in our guide to Lovable alternatives that don't charge for AI twice.

The second is the backend. On Lovable, the serious stuff (database, auth, storage) lives in Supabase or Lovable Cloud, which is a second system to understand, secure, and pay for. On Floot, the database, user accounts, file storage, payments, and hosting are part of the platform.

The third is where you build. Floot works over MCP, so your Claude or ChatGPT chat is the editor. If that model is new to you, here's a plain-English guide to MCP, and for the head-to-head comparison, see Floot vs Lovable.

Step 1: Get your code out of Lovable

Lovable's official export path is GitHub. In your Lovable project, connect GitHub from the project settings and Lovable pushes your codebase to a repository it keeps in sync. From there, your code is yours: clone the repo, or just download it as a zip from GitHub.

Do this even if you're not sure about migrating yet. A copy of your own code in your own GitHub account is a good thing to have, whatever platform you build on.

Step 2: Import the project into Floot

Floot supports importing an existing code project; the Floot docs have the current walkthrough. Bring in the zip you just downloaded, and the import turns your Lovable codebase into a Floot project you can keep editing.

Because Lovable projects are React with Tailwind, the frontend translates well: your pages, components, layouts, and styling carry across, and from here on you iterate the Floot way, by describing changes in your Claude or ChatGPT chat. Watch the live preview link as the import settles, and fix anything that looks off with a sentence, the same loop as building a site with Claude from scratch.

Step 3: Rebuild the backend on Floot

This is the part to take seriously. Anything your app did through Supabase or Lovable Cloud (tables, logins, file uploads, edge functions) needs an equivalent on Floot's built-in backend.

The move is simpler than it sounds, because you don't port the plumbing, you re-describe the behavior. Not "recreate this Postgres policy," but "logged-in users can only see their own invoices." Not "rewrite this edge function," but "when someone submits this form, email me and save the entry." Claude rebuilds each piece on Floot's own database, auth, and storage, and the second system disappears: no separate Supabase project, no service keys to manage, no second dashboard.

Make a list of everything the old backend did (tables, logins, uploads, emails, scheduled jobs) and work through it one behavior at a time. Small apps have shorter lists than their owners expect.

Step 4: Move your data

If your app has real users and real records, this step decides whether the migration is invisible or embarrassing.

Export each table from your Supabase or Lovable Cloud dashboard (CSV is the boring, reliable format), then hand the files to Claude in your Floot chat and ask it to import them into the new tables. Spot-check the results: row counts first, then a handful of real records end to end.

Two details deserve care. Files in storage buckets need to be re-uploaded to Floot's storage, so budget time if you have a lot of user uploads. And user passwords generally can't move between auth systems; the standard move is a password reset email to your users on cutover day, which is a normal thing users see and forgive.

Step 5: Point your domain and keep your SEO

When the new app checks out, connect your custom domain to the published Floot site; one click publishes it live, and the domain settings walk you through DNS.

If your old URLs earned any search ranking, don't throw it away. Set up server-side 301 redirects from any URL that changed so Google transfers your standing to the new pages, and make sure the important pages return real server-rendered HTML. Floot publishes with pre-rendering and sitemaps by default, which quietly handles most of that checklist.

Step 6: Run both for a week, then cancel

Keep the Lovable project alive for a week or two after cutover. It costs you a little patience and buys you a rollback plan while real traffic exercises the new site. Once the new version has taken real users through their real flows without surprises, export a final copy of any data that changed, then cancel the old subscription.

FAQ

Will my whole Lovable project transfer automatically?

The frontend comes across well, since it's standard React and Tailwind. The backend doesn't transfer file-for-file; you rebuild those behaviors on Floot's built-in backend, which is usually faster than it sounds because you describe what each piece does rather than porting code.

Do I need my code, or can Floot rebuild from a description?

Both work. Importing your exported code keeps your exact design and structure. For smaller projects, some people find it faster to give Claude the live URL and a description and have it rebuild fresh on Floot; screenshots of the old app help it match the design.

What happens to my Supabase data?

You export it (CSV from the dashboard is the dependable route) and import it into Floot's database. Plan a little extra time for storage buckets and remember that user passwords will need a reset on the new auth system.

Will I lose my Google rankings?

Not if you handle the cutover properly: keep URLs stable where you can, 301-redirect the ones that change, and publish server-rendered pages. Floot's publishing includes pre-rendering and sitemaps by default.

What does Floot cost compared to Lovable?

Floot is a flat subscription covering building, hosting, the database, and publishing, and building over MCP uses zero AI credits on top of your existing Claude or ChatGPT plan. The practical difference isn't just the number, it's the shape: no credit balance to watch while you work.

Your project, minus the meter

You already did the hard part: you built something people use. Moving it is an export, an import, a backend described in plain English, and a weekend of checking your work, and at the end your app runs on a flat subscription with your AI assistant as the editor.

Export your code from Lovable today, import it into Floot, and finish the move in the same chat you'll build in from now on.