Introduction
A Lovable app can look finished long before it is ready for strangers to use it. The preview proves the idea works for the person building it. Production adds people you have never met, data that has to stay separated, payments that cannot double-charge, and failures that have to reach someone.
This guide covers what changes between preview and production, the nine checks a Lovable app should pass before launch, the gaps we see most often in AI-built apps, and three ways to get there depending on how much you want to do yourself.
What you’ll learn
- What changes when a Lovable app goes live
- The nine checks to pass before launch
- The gaps AI-built apps most often have
- Whether to stay on Lovable Cloud or move to your own Supabase
- Three ways to get to production, from $99 to senior hardening
- How long it takes
What changes between a Lovable preview and production?
The users, the data and the consequences. In the preview, you are the only user, the data is yours, and a broken screen costs a re-prompt. In production, any visitor can call your backend directly, every row belongs to someone, and a failure might go unnoticed for days.
That is why many apps that work in the editor break after publishing. Production runs with different environment values, real sign-in redirects and row-level security the preview never exercised. If your app is already failing, start with our guides to an app that works in preview but not after publishing and a blank white screen.
Which checks should a Lovable app pass before launch?
The Zenveus Production Readiness Standard defines nine, each with a pass threshold and the evidence that counts. For a Lovable app they come down to these questions:
- Authentication and access control: can anyone reach an admin screen or promote themselves?
- Authorization and data isolation: is every read and write scoped to the right user, with row-level security on every table?
- Secret and key management: does any secret reach the browser, the repository or the logs?
- Input validation and error handling: is untrusted input bounded, AI inputs and outputs included, and do failures fail safely?
- Payments and transactional integrity: are payments and webhooks idempotent and replay-safe?
- Performance and scalability: are there rate limits and caps on runaway AI cost?
- Automated testing and CI: does anything stop a broken change to a payment or sign-in path from shipping?
- Observability and deployment: do failures reach a person, and does rollback work?
- Compliance and audit surface: is sensitive data classified and is access logged?
Authorization carries the most weight in the Standard on purpose, because data isolation is where AI-built apps most often leak. Our Lovable production readiness checklist turns these into steps you can work through.
Which gaps do AI-built apps most often have?
In the production issues we reviewed across about 25 projects in October 2026, three patterns came up most: authorization that was defined but not enforced, silent failures that showed success when the work had failed, and secrets in the wrong place. In a Lovable app those usually look like this:
- A Supabase table with row-level security off, or a policy that checks a user is signed in but not that the row is theirs. Test it with two accounts, or run our free Row-Level Security Auditor.
- A secret key, such as Supabase’s secret key (formerly the service_role key) or an AI provider key, in client code. Supabase’s publishable key is meant to be public and only reaches what row-level security allows; the secret key bypasses it (Supabase). Our Secret Scanner checks a repository for exposed credentials.
- Demo data, fallback values or a “saved” message that appears whether or not anything saved. We wrote about this pattern in fake success in AI-built apps.
- An Edge Function that does work before checking who is calling, or that fails without telling the interface. See Edge Function CORS and 500 errors.
Should you stay on Lovable Cloud or move to your own Supabase?
Either can run in production. Lovable Cloud is the built-in backend Lovable provides on Supabase’s open-source foundation, with the database, authentication and storage set up for you. Your own Supabase project gives you direct control of settings, backups, billing and agreements such as a BAA.
Decide early if you think you will need your own project. Lovable’s docs say moving from the built-in backend to your own Supabase project is not a one-step change: you export and restore the database, move storage files and code, and set up authentication, secrets and external services again (Lovable Cloud). That is far easier with ten test users than with ten thousand customers. If you will handle health data, read HIPAA for Lovable and Supabase apps first.
Whichever backend you use, connect the project to GitHub. Lovable supports export and two-way sync with GitHub (Lovable), which gives you a backup, a history of every change, and a way for an engineer to review and fix the code without leaving Lovable behind.
What are the ways to get a Lovable app to production?
Three, depending on how much you want to do yourself.
- Do it yourself with structure. The 7-Day Launch Readiness Sprint is $99. You test the running app against the nine-area Standard, one focused session a day, and finish with a Ready, Conditional release or Hold decision and a ranked fix list. No code access is needed.
- Get a senior engineer’s decision. The 48-Hour Verdict is $299, or $199 for sprint buyers. A named senior engineer reads your code and signs a written decision against the Standard with evidence and a prioritized fix list.
- Have it hardened. AI Prototype Hardening starts with a one-to-two-week technical audit, then senior engineers keep what works, repair what is fragile, and rebuild only where the evidence says so.
If something specific is already broken, we fix Lovable apps in your own code. If the main worry is who can read which rows, the Supabase security audit focuses on row-level security, keys, storage and Edge Functions.
How long does it take to take a Lovable app to production?
The gaps set the timeline more than the size of the app does. The sprint runs over seven sessions of 60 to 120 minutes. The Verdict arrives within 48 hours of access. Hardening starts with a one-to-two-week audit, and the repair plan sets the rest of the timeline.
Most of the time goes into the first three checks: sign-in, data isolation and secrets. They are also the ones that cause the most damage if they slip through, which is why they come first. If the problems turn out to be structural, our Refactor or Rebuild Decision gives you a reasoned answer before you spend on either.
NEXT STEP
Know whether your Lovable app is ready to launch
A named senior engineer reviews your Lovable codebase against the Production Readiness Standard and signs a written verdict in 48 hours: what blocks launch, what can wait, and what to fix first.
Get the 48-Hour Verdict ($299)For incidents affecting AI-built apps right now, with what to do for each, see Security alerts for AI-built apps.
