Lovable Drafts: What's Actually Isolated and Where Your Draft Still Hits the Live App
Lovable Drafts are working copies of your project, each with its own chat and preview. A draft only gets its own test database on Lovable's built-in backend, while with your own Supabase project it changes real data. Either way, secrets and connected services stay live, and database changes reach the live database when you accept the draft, not when you publish.
What are Lovable Drafts?
A draft is a copy of your project where you try out changes without touching the main version. Lovable introduced the feature on its blog on November 16, 2026. Each draft has its own chat and its own preview. To create one, click the project name at the top of the editor and choose "New draft".
The key facts from the documentation:
- Drafts are available on all plans. To work in one, you need edit access.
- Creating, updating, accepting, and deleting a draft uses no credits. Messages in a draft cost the same as in the main version. Our article on Lovable credits explains how the balance works.
- A project can have up to 500 open drafts. A new draft that nobody touches for 24 hours gets removed.
- Accepting a draft moves its changes into the project's unpublished changes. Visitors only see them once you publish the main version. You can't publish a draft itself.
The details that matter for an app with real users sit further down in the documentation.
Does a draft work with real data or test data?
It depends on where your backend lives, meaning your database, user accounts, and files. There are two kinds of drafts.
Draft with its own backend: If your project runs on Lovable's built-in backend, the draft gets a backend of its own, according to the changelog entry from November 16. It contains the structure of your live database, filled with example data instead of real records. A banner above the preview says you're viewing example data. Whatever you enter there stays in the draft.
Draft on the live backend: If your project uses your own Supabase project, the draft shares its database, accounts, and files with the live app. The same happens when Lovable can't set up the draft's backend, for example because of an unsupported database extension. Delete a record in a draft like this and you delete it in the live app. Discarding the draft doesn't undo that.
| Draft with its own backend | Draft on the live backend | |
|---|---|---|
| Applies when | built-in Lovable backend | your own Supabase project, or setup failed |
| Database | copy of the structure with example data | the real live database |
| Accounts and files | separate from the live app | the real ones |
| Backend functions | its own copies running the draft's code | editable, deployed only on accept |
| Secrets, connected services | live | live |
| Deleting the draft | test data is gone | data changes stay |
What is never isolated in a draft?
Secrets and connected services. Secrets are the access keys stored for your app, for example for an email provider or a CRM. A draft always uses the live values. A service call from a draft is real: the record lands in your CRM, the email goes out through your email provider. There are no separate test secrets.
More points from the documentation:
- Payments: Built-in payments run in test mode in a draft. With your own Stripe account and a live key, the payment is real.
- Emails: Sign-in emails do get sent, up to 20 per hour per draft and 100 per project. Lovable doesn't send other built-in emails from a draft.
- Files in the Files tab are shared between the main version and every draft. Changes take effect right away.
- The Database, Users, and Storage views are disabled in the More menu of a draft with its own backend, because they show live data. Open them through a direct link and you see the real data, not the example data.
- Sign-in methods and storage settings can't be changed in a draft on the live backend, only in the main version. Single sign-on through SAML doesn't work in a draft.
- Git: A draft doesn't show up as a branch in your connected repository. The code only arrives there after you accept.
What happens to the database when you accept a draft?
Structure changes are applied to the live database the moment you accept, not when you publish. According to the documentation, the same goes for backend functions and storage settings. This is where production apps can get hurt:
- The old version runs on the new structure. Until you publish, visitors see the previous app, already working with the changed database. If the draft renames or removes a column, the old version can break.
- There is no automatic backup. Lovable doesn't back up the database before accepting and recommends exporting it first.
- Rolling back doesn't bring the database back. Version history restores code and backend functions, not the database.
- Test data never comes along. Rows, test accounts, and files from a draft with its own backend are deleted with the draft.
There are two safeguards. If one structure change fails, Lovable applies none of them and doesn't add the draft's code either. And in a draft on the live backend, Lovable doesn't rename or remove existing tables and columns. It adds to the database and leaves the old parts in place.
Anyone with edit access can accept a draft, with no approval from a second person. Since November 17, AI clients can also create drafts and build in them through the Lovable MCP server, and according to the documentation they can accept and delete drafts too. MCP is the interface that lets tools like Claude or ChatGPT operate other software.
What does this mean for you?
Prototype or internal tool on the Lovable backend: Drafts are a real win. You try three variants in parallel without test entries ending up next to real data. Watch for the example data banner. It appears once the draft has finished setting up. If you don't see it at that point, assume you're working on real data and check before you delete anything.
App with your own Supabase project: Here a draft isolates the code, not the data. That covers a lot of apps that have outgrown the prototype stage. Our take: it's still useful for interface, copy, and flows. It doesn't work as a test environment for anything that writes or deletes data. For that, a second Supabase project with test data remains the safe route.
Before every accept on an app with real users:
- Export the database.
- Check whether the draft renames or removes tables or columns. If it does: add first, publish, clean up later.
- Schedule accepting and publishing back to back, ideally at a quiet time.
- Agree as a team on who accepts. Technically, anyone with edit access can, including a connected AI client.
- Only trigger features that send emails or data to outside systems with test recipients while you're in a draft.
Drafts take away the biggest worry when you keep building: the fear of wrecking the running app with a single prompt. They don't take responsibility for data and operations off anyone's plate. Where that line runs for AI-built apps is covered in our guide to vibe coding. If you're not sure which kind of draft your project gets, we're happy to take a look with you.
Frequently asked questions
Can I show a client a draft through a link?
Not through the preview link. According to the documentation, it always shows the main version, never a draft. Anyone who should see a draft needs access to the project. With view access, they can switch between drafts but can't accept or delete anything.
What happens when two people accept drafts at the same time?
Lovable puts them in a queue and accepts them one after another. The queue holds 10 drafts. Before a draft is accepted, it's brought up to date with the current state of the project.
Can I pull real records into a draft with example data?
Yes, you can copy selected rows from the live database into the example data. Lovable asks before copying personal information and doesn't copy user accounts. Keep privacy in mind: a copy of real customer data is still customer data.
Does my draft pick up changes made to the main version in the meantime?
Not on its own. You have to update the draft, and then Lovable pulls in the newer changes. At the latest, this happens automatically when you accept.
Sources
Tell us what you're planning. You'll get an honest assessment within 24 hours.
More articles