Lovable drafts can finally touch your database: try schema changes in a copy first
Lovable's 16 November update gives drafts their own backend with example data, so database changes can be tested in a copy. Accepting applies the schema change to the live database while test data stays behind — but accepting is not publishing, and the rollback question is still open.

One sentence: drafts now have their own database
On 16 November 2026, Lovable shipped a small changelog entry that matters a lot to vibe coders: drafts now come with their own backend. If your project uses Lovable's built-in backend, a new draft gets a backend of its own, filled with example data. You can test a change that writes to the database — say, adding a field to a sign-up form — without worrying that test entries will end up next to your real users' data. When you accept the draft, Lovable applies the change to your live database before you publish, and leaves the test data behind.
This update deserves its own article, not because it is grand, but because it closes the most important gap in the drafts feature. Drafts themselves launched on 7 September 2026. The first version only covered the front end: you could copy an app, change the layout, rewrite copy, and compare several versions side by side while the live app stayed untouched. But the moment your change touched the database, the first version could not help — drafts shared the live project's data, so fake entries typed in during testing landed right next to real user data. The 16 November update closes that line: a draft goes from being a parallel world for the front end to a parallel world for the whole app, backend included.
One correction up front, because several aggregators got it wrong on the day. Some outlets wrote the 16 November news up as "Lovable launches Drafts". That is incorrect. Drafts were not launched on 16 November; they went live in early September, and several explainers were already describing them between 8 and 11 September. What is genuinely new on 16 November is database changes inside drafts: a draft gets its own backend with example data, and accepting it syncs only the structural change to the live database. This article follows Lovable's own changelog and blog post, and its timeline follows those two sources.
What exactly changed
In the changelog's own words, the mechanism works like this: on a project that uses the built-in backend, a draft now has a backend of its own, filled with example data. In the draft, you can test a change that stores new information, such as a new form field, without changing your live app. When you accept the draft, Lovable applies the change to your live database before you publish, and leaves the test data behind.
The blog post spells it out further. Open a project, click its name at the top of the editor, and hit "New draft", and Lovable creates a complete copy of your app, from design to database. Each draft has its own chat and preview, and you can create as many as you like. When you are happy with a draft, accept it to add its changes to your project, then hit publish to make them live. Any data you add while testing stays in the draft and is cleared when you accept or delete it, so it never lands next to real customer data. Changed your mind? Before you accept, just delete the draft. After you accept, you can still roll it back before you publish: open History, pick the version from before you accepted, and hit revert.
One detail deserves to be pulled out on its own, because it is the easiest to misunderstand: accepting is not publishing. Lovable's documentation is explicit that your published app changes only when you publish, not when you accept a draft. But database changes are different — the moment you accept, the structural change is applied to the live database, and publishing only pushes the interface and code live. So between accepting and publishing, the database and the published app are briefly out of sync: the new field already exists in the database, while the live app does not know about it yet. That is usually harmless — a new field just sits empty — but you should know it is happening: accepting is not a consequence-free rehearsal. It already touches the live database.
The blog also gives concrete examples of what you can now do: a new field on a sign-up or booking form; who-can-see-what, like a members-only page or an admin view; a new dashboard, seen with months of example data; new tables and records, without test entries landing next to real user data; deposits, a waitlist, or a new booking flow, visualised with a full example calendar. They share one trait: they are all changes you would not dare to make until you have seen them run with realistic-looking data first.
Why the backend step matters most
For vibe coders without a technical background, changing the front end and changing the database feel like two completely different kinds of risk. Change a colour or rewrite a line of copy and the worst case is that it looks off; add a field or restructure a table and a mistake can pollute real user data or break the live app outright. The September version of drafts only solved half the problem: interfaces could be tried freely, databases could not be touched. The result was that the changes most in need of repeated testing — adding fields, changing forms, building member permissions — were exactly the ones drafts did not cover, so people either edited the live version directly or did not dare to change anything at all.
The 16 November update extends the "safe to try" zone to the database. The point is not technical complexity; it is that the update separates two things: structural changes and test data. When you accept a draft, the structure moves across and the data stays behind. That asymmetry is the whole idea. The structure is what you want; the test data is rubbish you created along the way while trying things out. Handling them separately is the only approach that makes sense. If accepting carried the test data across too, drafts would be pointless; if the structure did not cross either, drafts would be decorative.
Put another way, Lovable is bringing the "branch" thinking programmers have used for years to people who will never touch Git. A programmer opens a branch, changes code, merges, and deploys, with database migrations handled as a separate step. A Lovable draft is a branch for app builders: copy, change freely, look at the result, decide whether to keep it. Before 16 November, that branch was missing its database half. Now that it is filled in, the mechanism is finally complete — and for projects already serving real users on Lovable, this is the point where drafts become genuinely usable.
Three uses worth trying first
The first is adding a field. Your app is live with real users, and you want to add a "company size" field to the sign-up form. The old way was to edit the live version directly, and see the effect immediately — including every fake company you typed in while testing. Add the field, notice the position is wrong or the options are incomplete, and you have to touch the live version again. Now you can add the field in a draft, fill it with example data to try every option, and check whether the form breaks on a phone screen, before accepting. The fake companies you typed will never appear in your users table.
The second is permissions and member pages. Suppose you want a page only paying members can enter, or a view only admins can see. These changes are the hardest to test, because you need to see both what an authorised person sees and what an unauthorised person sees. A draft comes with complete example data, so you can walk both identities through the copy, confirm that the person without permission genuinely cannot get in, and then accept. Lovable's blog singles this example out, which suggests they know permission changes are the category people are most afraid to ship directly.
The third is side-by-side comparison. You can open as many drafts as you like, so you can ask Lovable to produce two or three versions of the same request — one bolder, one more conservative — each running with its own example data, and compare them next to each other. September's drafts could already do this for the front end; now changes that touch the database can be compared the same way. Two different booking flows, each with a full example calendar: which one feels smoother is obvious at a glance.
Four things not to get wrong
First, accepting a draft touches the live database first. As explained above, the structural change lands in the live database the moment you accept, and publishing only pushes the interface and code. If you accept a draft and then leave it unpublished for a long time, the live database gains a field nobody is using yet. That is not an incident, but it is not zero cost either. Build the habit: check everything once before accepting, and publish promptly afterwards, so the database and the app do not drift apart for long.
Second, it is not clear whether rolling back also undoes the database change. The blog says that after accepting and before publishing, you can use History to revert to the version from before you accepted. That describes the app version; neither the changelog nor the blog states explicitly whether a field already applied to the live database gets removed too. The safe reading is to treat rollback as reverting the interface and code, and to verify database changes separately — do not assume they disappear on their own.
Third, not every backend change can be made in a draft. The changelog's earlier entry on exploring changes with drafts says that some backend changes still have to be made in the main version of your project. The documentation does not list which ones. So draft coverage of the backend is not one hundred percent, and complex backend adjustments may still require going back to the main version. If you hit a backend change a draft cannot do, do not force it — back up your data before touching the main version.
Fourth, the announcement says nothing about which plans include drafts or whether drafts consume extra credits. Neither the changelog nor the blog mentions plan limits or credit costs. Do not assume every user gets it, and do not assume it is free — open one of your own projects and check that "New draft" is there.
The same release carried plenty of other items: chats can be archived, SSO sessions can be set to 30 days or indefinite, Intercom can be connected, preview comments can be numbered and dragged to a different element, sign-ups are checked against known password leaks, and more. 16 November was a fairly large Lovable release, and the draft backend is only one line in it. But for anyone already running a real app on Lovable, it is the line worth trying first.
Drafts, Git branches, and preview deployments: what is actually different
An experienced developer hearing "copy it and change it freely" might think: that is just a Git branch. It resembles one, but it is not the same thing. A Git branch manages code; a Lovable draft manages the whole app — interface, chat history, preview, and now the database. A programmer opening a branch has to decide in advance which files to change; a Lovable draft is one click on the project name and the copy arrives with its database and example data included. The barrier to entry is not in the same league.
Compared with preview deployments — the preview link Vercel generates for every pull request, for example — the difference is where the change happens. A preview deployment shows you code that is already written, deployed as a copy so you can look at it; the change itself still happens in code. A draft puts the act of changing inside the copy as well: every message and every adjustment you make in a draft affects only the copy. Before you accept, the main version cannot even see your trial and error. For builders without a technical background, that matters: they do not have to learn "write code, then look at the result" first; they change things in the copy and watch as they go.
There is also a difference in how data is handled. A programmer's branch usually points at the same development database, or at a separately configured set of test data, and keeping test data out of production relies on process and discipline. Lovable builds that discipline into the product: a draft's test data is cleared automatically when you accept or delete it, so you never have to remember to clean up. The cost is a little flexibility — you cannot carry a few realistic-looking example rows from a draft into the live database; if you want to keep them, you type them again. That is a reasonable trade: for an app with real users, the cost of test data leaking into production is far higher than the cost of retyping a few rows.
So do not think of drafts as a cut-down Git. They are closer to a branching mechanism with a database attached, built for people who do not write code. Their competitor is not Git; it is the bad habit of editing the live version directly. Before 16 November, that mechanism had an obvious hole: database changes were outside its protection. Now the hole is filled, and the mechanism is complete.
Try it once this week: five steps
Step one: pick a small change. Do not start by restructuring the whole database. Choose one field you have wanted to add but did not dare to — a "notes" field on orders, or a "how did you hear about us" field on users. The smaller the change, the clearer the feedback from a first try.
Step two: click the project name and open a new draft. Add the field in the draft by chatting, then ask Lovable to fill the form with example data and look at what the new field does to the list page and the detail page. Check two things: whether the example data looks real enough to expose layout problems, and whether the new field crowds the existing page.
Step three: walk the unhappy paths in the draft as well. What does the field look like left empty? What happens when someone types something very long — does it break the layout? If it is member-only content, open it once as a person without permission and confirm they genuinely cannot see it. This takes a few minutes and catches most problems that would otherwise surface only after launch.
Step four: pause and check once before accepting. Accepting applies the structural change to the live database, and the test data will not follow. Confirm that this is the field, the name, and the position you want, then accept — and publish promptly afterwards, so the database and the app do not stay out of sync for long.
Step five: after publishing, look at the live database once. Confirm the new field is there, the test data did not follow, and no fake users appeared in your users table. This step builds trust: once you have seen with your own eyes that the test data genuinely stayed behind, you will feel safe using drafts for bigger changes next time.
The same changelog carries one item unrelated to drafts that every Lovable user should know: Gemini 3.6 Flash is deprecated and stops working for your app's AI features after 19 November 2026. Apps already using it keep working until then, and Lovable no longer picks it for new AI features; Gemini 3.7 Flash has taken over as the default. If your app names a model explicitly, nothing changes; if it does not, it has already quietly moved to 3.7. It shipped on the same day as the drafts backend, so checking which model your app uses now is cheaper than finding out after the old one stops.
What it means for vibe coders
In one sentence: Lovable drafts have finally grown from a sandbox for playing with designs into a sandbox you can trust with production data. The September version answered "what if I break the interface"; the 16 November version answers "what if I break the database". The second question is the one that actually stopped people from iterating.
If you already run an app with real users on Lovable, try it once this week: pick a field you have wanted to add but did not dare to, build it in a draft, look at it properly, and then accept. Remember the order of the two actions: accepting moves the database, publishing moves the app. Check the structure once before accepting, and publish soon after. As for the articles claiming Lovable only launched Drafts on 16 November, you can skip them — the feature has existed since September; what November added is the backend half, which was the part that mattered most.
Comments (0)
Sources
Related articles
On 17 November 2026, Microsoft launched MAI Code 2 and Code 2 Flash: the larger model has 77 billion active parameters and a one-million-token context, averaging 63.2% across four benchmarks — close to GPT-6.1 Sol and Claude Opus 5.5 — at $0.309 per task. Read the three caveats first: promotional pricing, the lowest score of the three, and no long-horizon work.
On 11 November 2026, AWS open-sourced UAEF: adapters turn traces from LangGraph, LangChain, Strands and Bedrock AgentCore into one format, then 36 metrics across 7 dimensions score them, flagging regressions past 5%. The judge model is hardened too — scores must cite verbatim evidence, and never decide safety.
On 17 November 2026, Perplexity launched the Orchestrator API: one interface reaching OpenAI, Anthropic, Google, xAI and open-weight models such as GLM, Kimi and DeepSeek, billed at the answering model's published rate with no platform fee. When one provider fails, the same model retries on another deployment, and preview routing assigns requests to models by task.