Short answer
Publishing a Lovable app takes one click, but production means more: your own domain, a production Supabase project separate from development, row level security that is actually tested, error monitoring and a release routine. Most teams can get there in one to two weeks without leaving Lovable.
On this page
- Publishing is not the same as production
- Layer 1: domain and identity
- Layer 2: split development from production
- Layer 3: secure the data before you announce anything
- Layer 4: monitoring you will actually look at
- Layer 5: a release routine for prompt-driven code
- Backups, compliance and the boring essentials
- When the web app should also be a mobile app
- A realistic plan
- FAQ
- Tools from the jocapps ecosystem
Publishing is not the same as production
Lovable makes the first deploy trivial. You press publish, get a URL, and the app is live. For a demo that is enough. For an app that customers or colleagues rely on, "live" needs to mean something more specific: the app runs on your domain, data changes are reversible, failures are visible to you before users report them, and a prompt that breaks something does not reach users instantly.
This article walks through those layers in the order we usually tackle them with teams that come to us with a Lovable app and a launch date.
Layer 1: domain and identity
Connect a custom domain in Lovable's project settings and set the DNS records your registrar needs. Decide early whether the app lives at the apex domain or a subdomain such as app.yourcompany.com; the subdomain is usually easier, because your marketing site can stay where it is.
While you are in DNS:
- Configure SPF, DKIM and DMARC for the domain that sends authentication emails, otherwise Supabase sign-up and password reset emails end up in spam.
- Switch Supabase Auth to a proper SMTP provider; the default sender is meant for testing and has low rate limits.
- Update the Site URL and redirect URLs in Supabase Auth to the production domain, or magic links and OAuth callbacks will point to the preview.
Layer 2: split development from production
The biggest structural risk in a Lovable app is that the editor, the preview and real users all talk to the same Supabase database. One prompt that generates a migration can alter tables your customers are writing to.
A sane setup looks like this:
| Environment | Supabase project | Who uses it | How changes arrive |
|---|---|---|---|
| Development | Dev project | Lovable editor and preview | Prompts, freely |
| Production | Separate prod project | Real users | Reviewed migrations only |
To get there, connect the Lovable project to GitHub so the code and the Supabase migration files are versioned. Create a second Supabase project for production, apply the migrations there, and point the production build at it through environment variables. From then on, schema changes reach production deliberately, not as a side effect of a chat message.
If this sounds like more than Lovable's hosting comfortably supports for your case, that is the moment to consider hosting the exported code yourself; we cover that path in migrating a Lovable app to your own infrastructure.
Layer 3: secure the data before you announce anything
Lovable apps typically rely on Supabase row level security (RLS) as the only barrier between users. The front end uses the public anon key, so the policies are your access control. Before launch:
- Confirm RLS is enabled on every table that holds user data.
- Write down, per table, who should read and write which rows, and compare that to the actual policies.
- Test with two ordinary accounts: can user A see or modify user B's records through the API, not just through the UI?
- Move anything using the service role key into Edge Functions; it must never appear in front-end code.
- Check storage buckets: public buckets are readable by anyone with the URL.
Lovable includes a security scan that catches common issues, which is useful but not a substitute for the two-account test above.
Layer 4: monitoring you will actually look at
Production problems in AI-built apps are rarely exotic. They are an Edge Function timing out, an email provider rejecting messages, or a policy that blocks a legitimate query and leaves a blank screen. Set up:
- Front-end error tracking (Sentry or similar) added to the React app, with source maps, so you see stack traces from real browsers.
- Uptime checks against the home page and one authenticated health endpoint.
- Supabase logs and usage alerts for database size, egress and function invocations, so plan limits do not surprise you.
- Product analytics with a privacy-friendly tool, configured to respect your cookie consent.
Route alerts to a channel someone reads. A dashboard nobody opens is not monitoring.
Layer 5: a release routine for prompt-driven code
The speed of Lovable is also its risk: each prompt can touch many files. A lightweight routine keeps that speed while protecting users:
- Work on a branch or in the dev environment.
- Before publishing, click through the five flows that matter most (sign-up, login, the core action, payment if any, settings).
- Review the GitHub diff for unexpected changes to auth, RLS or payment code.
- Apply any new migrations to production, then publish.
- Keep the previous version available so you can roll back in minutes.
For teams that want the review step done by someone who reads code for a living, OnlineAppCreator provides AI Code Engineers who take over the production side of AI-built apps: environment separation, RLS review, monitoring and an SLA for incidents, while your team keeps building features in Lovable.
Backups, compliance and the boring essentials
- Enable point-in-time recovery or at least daily backups on the production Supabase project, and test a restore once.
- Choose a Supabase region that matches your data residency needs; for EU users, an EU region simplifies GDPR documentation.
- Publish a privacy policy and imprint that list Lovable's hosting, Supabase and any AI APIs as processors.
- Store third-party API keys as Supabase secrets, not in the repository.
When the web app should also be a mobile app
Once the production setup is stable, many teams want an app store presence. Because a Lovable app is a responsive web app, the quickest route is a native shell around the production URL. WebViewGold converts the hosted app into iOS and Android apps with push notifications and native features, and your Lovable updates keep flowing to the apps without new store releases. The details are in publishing a Lovable app to the App Store.
A realistic plan
- Week 1: domain, SMTP, GitHub sync, separate production Supabase project, RLS review.
- Week 2: monitoring, backups, release routine, legal pages, soft launch to a small group.
If you need that done faster or with a guarantee, OnlineAppCreator can take it on as a fixed-scope engagement. We have taken many AI prototypes this route, and the pattern above is the one that survives contact with real users.
FAQ
Is Lovable hosting good enough for production?
For many small and mid-sized apps, yes, provided you add a custom domain, a separate production database, tested RLS and monitoring. Teams with strict compliance, custom infrastructure or high traffic often export to their own hosting.
How do I separate development and production in Lovable?
Use two Supabase projects. Keep the Lovable editor connected to development, version migrations through GitHub, and apply them to the production project only after review.
What is the most common security issue in Lovable apps?
Missing or too permissive row level security policies. Test with two separate user accounts against the API, not just through the interface.
Can I roll back a bad Lovable deploy?
Lovable keeps a version history you can restore, and a GitHub connection gives you a second safety net. Database migrations need their own rollback plan, which is why they should reach production separately.