Code export · Lovable
Lovable gives you code. It does not give you a codebase
Export policy checked on September 2026
What comes out
What Lovable actually exports.
Lovable is one of the builders that hands you real, self-hostable source. What comes out is a conventional React/TypeScript app with a Supabase backend — nothing proprietary, so it deploys like any other modern web app.
React + TypeScript front end
Vite, Tailwind, shadcn/ui (Radix) and React Router — the mainstream stack a JavaScript developer already knows.
Supabase backend
Postgres, Auth, Storage, Deno edge functions and Realtime — or the managed "Lovable Cloud" equivalent you can later detach.
Your own private repo
Repos are private and owned by you by default; you can host on Vercel, Netlify or your own infrastructure.
Two ways out
Two-way GitHub sync (documented on all plans) or a direct "Download codebase" from Project settings → Git.
How the export works: Connect GitHub from the project menu for a two-way sync (Lovable commits to the repo, and commits flow back into Lovable), or download the codebase as a one-off from Project settings → Git. Editing the same file in both places can cause sync conflicts, so most teams pick one direction of truth.
The gap
What the export does not include.
Owning the repo is real and it is a genuine advantage over a closed platform. But "you have the code" is not the same as "you have a product that is safe to run." These are the gaps the export leaves you holding.
Row-level security and auth rules need review
Lovable generates Supabase RLS policies and auth flows, and this is exactly where AI-generated apps have leaked data — the code is yours, but nobody has audited who can read which row. For a client portal, CRM or anything with real accounts, that review is the whole risk.
BlockerSources: [1]No tests, no CI
The export doesn't ship a test suite or a deployment pipeline. Until those exist, every change is a manual, unverified deploy — fine for a prototype, not for software real users depend on.
MajorData is a separate export
Your Supabase database contents come out separately from the code, and secrets/env keys aren't baked in — you supply your own Supabase keys when self-hosting. Detaching from Lovable Cloud adds a re-pointing step.
MinorSources: [1]Generated code is verbose and uneven
AI output can be repetitive and inconsistent across files. It compiles and runs, but an engineer taking it on will want a pass to normalise structure, remove duplication and tidy the edge functions before building on top.
Minor
The real question
Is the exported code maintainable?
Lovable export:Maintainable
This is the good news for Lovable: because it emits conventional React/TypeScript and standard Supabase, a hired engineer can pick it up without learning a proprietary format, and it deploys to Vercel or Netlify with no special steps. The work isn't decoding a weird export — it's the normal hardening any fast-built app needs: reviewing the RLS policies, adding tests and CI, and tidying the AI's verbosity. That's a reviewed rebuild on top of a real foundation, not a rescue from a dead end.
Your options
What to do with the export.
Three honest routes. The right one depends on how far the app has to go and who is going to own the code once it gets there.
- 01
Keep building on it yourself
Keep iterating in Lovable and let the GitHub sync mirror it. You stay fast and you still own the repo as a safety net.
- Right when you're pre-launch, validating, and no real user data is at stake yet.
- Wrong when you already have paying users and unreviewed security rules.
- 02
Hire an engineer to take it on
Hand the exported repo to a developer who reviews the RLS and auth, adds tests and CI, and owns the codebase going forward.
- Right when the app is roughly right and you want to keep the structure but make it safe and maintainable.
- 03
Have it rebuilt or hardened
Start from the export and do a reviewed hardening pass — or rebuild the parts that won't scale — so the result is engineered, not just generated.
- Right when the product has to hold real users, payments and data, and "generated" isn't a good enough answer for that.
"You own the code" — what that's worth, line by line
Lovable's export is a real advantage, and it's worth being precise about which parts it solves and which it doesn't. Ownership and portability: solved — you have a standard React/Supabase repo you can host anywhere. Maintainability of the stack: solved — it's mainstream code, not a proprietary format. Security review, tests, CI, and data migration: not solved — those are the work that turns a generated app into a production one. The gap between the two columns is exactly what a reviewed rebuild closes.
- Stack
- React + Supabase
- Repo ownership
- Yours
- Security reviewed
- No
- Tests / CI
- None
Sources: [1]
FAQ
Questions people actually ask.
- Is Lovable's GitHub sync one-way or two-way?
- Two-way. Lovable commits your project to the connected GitHub repo, and commits you push back into that repo flow into Lovable. The one caution is editing the same file in both Lovable and GitHub at once, which can cause sync conflicts — so most teams treat one side as the source of truth.
- Can I export code on Lovable's free plan?
- Lovable's own docs describe the github.com integration as available on all plans, with GitHub Enterprise reserved for the Enterprise tier, plus an in-app "Download codebase" option. Some third-party guides still claim the free plan is download-only — so if free-plan export matters to you, confirm it against Lovable's current pricing page before committing.
- Does the export include the Supabase backend and database?
- The code that talks to Supabase comes out, but your database contents are a separate export, and secrets aren't baked in — you supply your own Supabase keys when self-hosting. If you built on Lovable Cloud rather than your own Supabase, detaching adds a re-pointing step.
- Can I self-host a Lovable app outside Lovable Cloud?
- Yes. Because it's standard React/Supabase, you can host the front end on Vercel, Netlify or your own infrastructure and point it at your own Supabase project. That portability is the real payoff of Lovable's export over a closed platform like Bubble.
- Is a Lovable app production-ready out of the box?
- Not out of the box. It's a real, runnable app, but generated code frequently has gaps in row-level security, auth and testing — the areas that matter most once you have real accounts and payments. It's a strong starting point that needs a review pass, not a finished product.
Every builder, one table
Code export across the hub, at a glance.
The same status table on every export page. “Exports” means real, usable source comes out; “partial” means a major layer is missing; “none” means no source export at all. The nuance is on each page.
| Platform | Code export | What you get |
|---|---|---|
| LovableThis page | Exports code | React repo via GitHub |
| Base44 | Partial export | Front end; backend locked |
| Webflow | Partial export | Front end only, no CMS |
| FlutterFlow | Exports code | Dart / Flutter source |
| Framer | No code export | Host-only, no export |
| Bolt.new | Exports code | Project files / GitHub |
| Bubble | No code export | No source export |
| Replit | Exports code | Full code, you own it |
| Softr | No code export | No code (data only) |
| Glide | No code export | No code (data only) |
| Adalo | No code export | No source export |
| Retool | Partial export | Self-host, not source |
| Xano | Partial export | API portable, no export |
Sources
Every claim, traced to a primary source.
The numbered references in the body link here. We cite vendor docs, pricing pages, changelogs and named reporting — dated where the document is dated, so the page can be re-audited each quarter.
- [01]Sync your Lovable project with GitHub
Lovable Documentationdocs.lovable.dev
- [02]v0 vs. Lovable — generated stack and portability
Vercelvercel.com
- [03]Application and data ownership — Bubble has no code export
Bubble Docsmanual.bubble.io
Own the Lovable app outright?
We’ll map the route to code you actually own.
Book a call with Jackson, our Growth Partner — he’ll walk your export or app, the gaps that matter, and a fixed-price plan to get it production-ready, live on your screen. Or get an instant estimate first.
Or see fixed-price migration packages and how we work.