How to Deploy a Lovable App to a Permanent URL (With a Real Backend)

You just built something real in Lovable. The preview link works, the demo impresses, and your client is asking when they can send it to their customers. Then you hit the wall: the preview URL expires, there is no database behind it, and the form you built does not actually save submissions anywhere. You need to deploy a Lovable app to a permanent URL, and you need a real backend to go with it. This guide covers exactly that: going from a Lovable project to a production-ready, custom-domain URL with a database, server-side logic, and form capture, all in under ten minutes. No stitching together four services with four different billing meters. Just one deployment that actually works for client delivery.

Table of Contents

• The Problem With Most Lovable Deployments
• What You Actually Need for a Production Lovable App
• Step-by-Step: How to Deploy a Lovable App to a Permanent URL
• What About Lovable Cloud? (And Why You Might Still Use It)
• Cost Comparison: Metered vs. Flat-Rate Hosting for Lovable Apps
• Common Mistakes When You Deploy a Lovable App (And How to Avoid Them)
• The 10-Minute Checklist: Deploy a Lovable App to Production
• Why "Deploy Lovable App" Tutorials Miss the Backend (And Why That Matters)

The Problem With Most Lovable Deployments

Lovable gives you a preview URL the moment you finish building. That URL is brilliant for showing your client what you made. It is not brilliant for running a business. Preview URLs expire. They sit on Lovable's subdomain with no custom domain support on the free tier. And the moment your app needs to write to a database, process a form submission, or run server-side logic, the preview falls apart.

Most "deploy Lovable app" tutorials point you toward static hosts: Netlify, Vercel's free tier, Cloudflare Pages. These services serve your frontend files without complaint. But they do not give you a database. They do not give you server functions that persist data. They do not capture form submissions unless you wire up a third-party service and pay for it separately. The tutorials stop at the static site step and call it done. You are left holding a shell of an app and a growing list of services you still need to configure.

The result is predictable. You spend an afternoon deploying to Netlify, then another afternoon setting up Supabase, then an evening configuring a serverless function runner for your contact form, then a morning debugging why the database connection string works locally but not in production. You are managing infrastructure instead of shipping features. Your client is waiting. And every service you add comes with its own usage meter, its own free tier cutoff, and its own potential surprise bill.

What You Actually Need for a Production Lovable App

A production app is not just a static HTML file served over HTTPS. It needs a permanent URL that does not expire and supports a custom domain with automatic SSL. It needs a real database, something like Postgres or D1, that persists data across sessions and survives redeploys. It needs server-side logic: edge functions or serverless endpoints that handle authentication, API calls, webhooks, and background work. It needs form submission capture so signups and leads do not vanish into the void. And it needs predictable pricing. When your client's app gets a traffic spike, your hosting bill should not spike with it.

If any one of those pieces is missing, you are not shipping a product. You are shipping a demo that someone else has to finish.

Step-by-Step: How to Deploy a Lovable App to a Permanent URL

Step 1: Export Your Lovable Project to GitHub

Lovable syncs to GitHub automatically if you connected your account during setup. Before you deploy, confirm your repository is current. Check that your environment variables, database connection strings, API keys, are stored as environment variables, not hardcoded into your source files. Lovable sometimes bakes these into the code during rapid prototyping. Pull them out now.

If you can, run a local build of the exported code. Catch the obvious failures before they hit your production URL. A build that fails locally will fail on any host.

Step 2: Choose a Host That Gives You a Backend, Not Just a Static Site

This is where most "deploy Lovable app" guides steer you wrong. They send you to Netlify or Vercel because those platforms make static deployment painless. And they do. But the moment your app needs a database, you are adding Supabase. The moment it needs form handling, you are adding a form service or wiring up a serverless function. The moment it needs transactional email, you are adding yet another integration. Each service bills separately. Each has its own usage limits. Each is a future point of failure.

The alternative is a flat-rate host that deploys your entire app, static or server-side rendered, with a per-site database, edge functions, and form capture all included. One call from your AI agent or CLI deploys the repo to a permanent URL with a custom domain in minutes. No account required to start. No credit card needed for the first deployment. You get a production backend without assembling it from spare parts.

Step 3: Connect a Custom Domain With Auto-DNS

A permanent URL means your own domain. Not a subdomain that expires when your free tier runs out. Not a preview link you cannot hand to a paying client.

Use Cloudflare for DNS. Most modern hosts auto-configure DNS records, SSL certificates, proxying, and caching in a single step. You point your domain to the deployment, and everything else is handled. The result is a URL your client owns, with HTTPS enabled by default, that will still be live a year from now.

Step 4: Add Your Database and Edge Functions

Lovable apps often use Supabase during development. That is fine for prototyping, but for production you want a database that lives alongside your deployment. Cloudflare D1 and Neon Postgres are both solid options. Migrate your schema, export your seed data if you have any, and point your production environment variables at the new database.

Edge functions replace the need for a separate server. They handle form submissions, webhook processing, API calls, and any server-side logic your app requires, without spinning up a VM or configuring a container. Deploy your functions alongside your frontend, test the database connection from the live domain, and confirm that reads and writes work before you send the URL to anyone.

Step 5: Set Up Form Capture and Transactional Email

If your Lovable app has a contact form, a signup flow, or an order page, those submissions need to go somewhere. Not to a third-party service you have to monitor. Not to a Zapier workflow that breaks when you change a field name. Straight to an inbox you control.

Built-in site data capture means every form submission lands in a dashboard you can check, export, or forward. Transactional email, welcome messages, password resets, order confirmations, hooks into the same backend. No separate SendGrid account. No Mailgun API key to rotate.

Step 6: Transfer Ownership to Your Client Cleanly

When the app is finished and your client is happy, you hand it off. Not just a zip file of the code. Not just a GitHub repo invite. The live URL, the database, the domain configuration, the form capture inbox, everything.

Atomic site ownership transfer moves the entire deployment to your client's account in one action. Stripe Connect payouts mean you get paid at the moment of transfer. No chasing invoices. No "I'll send the payment next week." The handoff is the transaction.

What About Lovable Cloud? (And Why You Might Still Use It)

Lovable Cloud is excellent for what it does: integrated development, instant previews, automatic security scanning before publish. If you are building an internal tool or a personal project, it is probably all you need. The workflow is smooth and the security scan catches real issues, like missing RLS policies, before your app goes live.

But for client delivery, Lovable Cloud has friction points. Free plan projects are public and forkable by anyone. Custom domains require a paid plan. Ownership transfer is not a first-class feature. And you are locked into Lovable's pricing structure, which may or may not match what your client is willing to pay long-term.

A hybrid approach works well: build and iterate inside Lovable, export to GitHub when the app is stable, and deploy to a flat-rate host that gives you the backend pieces Lovable Cloud does not include. You keep the fast prototyping workflow and gain a production URL your client can actually own.

Cost Comparison: Metered vs. Flat-Rate Hosting for Lovable Apps

Netlify's free tier gives you 100GB of bandwidth and 300 build minutes per month. That works for low-traffic apps, but forms cost extra beyond the first 100 submissions, and serverless functions have execution limits that can surprise you. Vercel's free tier is similar: generous for static sites, metered for everything else. AWS and Google Cloud charge for what you use, which scales beautifully for large teams and terribly for freelancers trying to quote a fixed price to a client.

Flat-rate hosting at $8 or $24 per month includes the database, the edge functions, the form capture, and the custom domain. One price. No usage meter. No bill that doubles because a client's marketing campaign drove unexpected traffic. If you want to compare your actual costs across platforms before committing, run the numbers through a hosting bill calculator. The difference between metered and flat-rate pricing becomes obvious the moment you stop building for yourself and start building for paying clients.

Common Mistakes When You Deploy a Lovable App (And How to Avoid Them)

The most frequent failure is forgetting to set environment variables in production. Your database URL works locally because it is in your .env file. It does not work on a remote host unless you explicitly add it. Check this first when something breaks.

Deploying without running Lovable's security scan is another common error. The Basic scan takes ten seconds and catches RLS policy mistakes that would expose your client's data. Run it before you send the URL.

Using the free plan's public URL for a client app is a mistake you make once. Anyone can fork a public Lovable project. Your client's competitors can inspect the source. Pay for privacy or export to a host that does not make your code public by default.

Finally, test database writes from the deployed domain before you call the project done. CORS misconfigurations, missing environment variables, and connection string errors all surface here. A read might work while a write silently fails.

The 10-Minute Checklist: Deploy a Lovable App to Production

Export code to GitHub and verify the build succeeds. Deploy to a host that includes database and edge functions, not just static file serving. Connect a custom domain via Cloudflare with auto-DNS. Migrate your database schema and test a write operation from the live URL. Set up form capture and confirm a test submission arrives in your inbox. Run Lovable's Basic security scan. Transfer ownership to your client or configure their billing. Confirm the URL resolves, HTTPS is active, and the backend is processing requests.

Why "Deploy Lovable App" Tutorials Miss the Backend (And Why That Matters)

Most deployment tutorials for Lovable end at the static host. They show you how to push to Netlify or Vercel and declare victory. They do not mention databases because adding a database complicates the tutorial. They do not cover server functions because that requires explaining environment variables, cold starts, and region selection. They do not address form handling because that means introducing a fourth service into an already long video.

The result is thousands of developers shipping static shells and then realizing, usually at midnight before a client meeting, that their app does not actually do anything. A permanent URL without a backend is not a production app. It is a brochure. If you are building for clients, the backend is the product. The frontend is just how they access it.

Shiply gives you that backend in one flat-rate deployment: database, edge functions, form capture, custom domain, and atomic ownership transfer, all included. No meters, no account required to start. When you are ready to ship your next Lovable app to a permanent URL, it is one call away.