
The short answer on Lovable self hosted is that you can host the apps Lovable builds. You can't self-host the Lovable editor or its AI agent.
Lovable's docs say both are managed services that can't run inside a customer VPC.
That leaves three paths. Export an app and host it, run apps in your own AWS account with Deploy on AWS, or use a platform that runs entirely in your account.
Lovable self hosted: what you can and can't move
You can self-host some parts of a Lovable app. Lovable's docs split an app into three independent parts, and only some can move.
The three parts of a Lovable app:
Lovable also offers Deploy on AWS and Deploy on Azure, both in private preview. They move your apps and their data into your cloud account, and the editor and agent stay with Lovable.
Three ways to run Lovable apps in your own cloud
How the three paths compare:
Path 1 gives you the most control and the most work. Path 2 keeps the Lovable experience and moves the apps. Path 3 replaces Lovable with a platform that runs in your account. The sections below cover each one.
What you'll need before starting
Prerequisites:
- A Lovable project, plus a GitHub, GitLab, or Bitbucket account.
- Access to the project's environment variables and, if it has a backend, its database.
- An account with the host you choose.
- A decision on the backend, either to leave it on Lovable's built-in backend or to move it to Supabase.
Time required: A static frontend can move in a few hours. An app with a backend, users, and files typically takes one to three days, with data restore and testing taking most of that. These are estimates.
Path 1: Export a Lovable app and host it yourself
Six steps take an app out of Lovable's hosting. Do them in order, because each one produces something the next needs.
Step 1: Get your source code out
Lovable gives you two ways to copy the code.
- Git sync: Available on all plans. Connect the project to GitHub, GitLab, or Bitbucket, and Lovable keeps both in sync.
- Download codebase: Available on paid plans. It's a one-time .zip snapshot. On Enterprise workspaces, admins can limit downloads to admins and owners.
Neither route includes your database records or your storage files. Those move separately in Step 4.
Pro tip: Use Git sync for anything ongoing. Hosts deploy from the repository, and Lovable can keep editing and previewing in the meantime.
Step 2: Check which stack your app uses
Lovable builds apps on one of two stacks, and each needs different hosting.
The two stacks and their hosting needs:
To tell which you have, open package.json in the Code tab. A TanStack Start project lists @tanstack/react-start under its dependencies.
This split is where self-hosting most often breaks. A host that only receives static files doesn't run a TanStack Start app's server code.
Step 3: Run it locally and recreate your variables
Clone the repository and run the app on your own computer first. A working local run shows what the app needs installed and which environment variables it reads, before a host adds its own settings.
Use Node.js 22 and npm run build. Variables that start with VITE_ are embedded at build time. Rebuild after you change them. Recreate each server secret by hand, because the repository doesn't hold them.
Step 4: Migrate the built-in backend to Supabase
If the app uses Lovable's built-in backend, the code in the repository doesn't include it. Lovable's supported destinations are managed Supabase and self-hosted Supabase.
Moving only the PostgreSQL database doesn't move authentication, storage, realtime, or Edge Functions, and Lovable doesn't support migrating to plain PostgreSQL.
How each piece of the backend moves:
Exports are limited to one every 24 hours. Time your final export carefully, because a second one must wait a day. For a self-hosted destination, Supabase documents self-hosting with Docker.
Pro tip: Test the restore on a fresh, empty Supabase project first. A failed trial run then costs nothing.
Step 5: Deploy to a host
Connect the repository to your host, set the build command to npm run build, and add your variables. Then add the new URL to your authentication provider's allowed redirect URLs.
For an older Vite app, add a fallback rewrite so every route serves /index.html. Otherwise, a direct visit to a nested route returns a 404.
Step 6: Verify, then connect your custom domain
Deploy to a temporary URL first and test it against the app running on Lovable.
Test these before you switch:
- Open a nested route directly and refresh it.
- Sign in and sign out.
- Run the reads, writes, and uploads the app depends on.
- For TanStack Start, load a server-rendered page and trigger a server function.
When it works, point your custom domain at the new host using that provider's instructions. Your lovable.app address stays with Lovable, and Lovable's Publish button still publishes only to Lovable hosting.
Download and verify your exports before you remove anything. Removing a database deletes the backend permanently.
Hosting options for a self-hosted Lovable app
This table uses Lovable's own hosting guidance. The effort column is my judgment.
Where each host stands:
Every option still needs a backend, either Lovable's built-in backend or Supabase.
Coolify is an open-source, self-hostable platform that deploys from Git or Docker onto a server you control. Lovable's docs don't mention it, so treat the Coolify row as an inference from its Docker support.
A note on free hosting and "Open Lovable"
Vercel's Hobby plan is limited to personal, non-commercial use. Check each host's terms before you pick a free tier.
Open Lovable is a different project. Firecrawl's open-source tool clones existing websites into React apps, and it is unrelated to Lovable's editor.
Lovable Deploy on AWS: what runs in your account
Lovable announced Deploy on AWS on October 14, 2026. This is the Lovable AWS route, also called Lovable BYOC (bring your own cloud). Lovable operates the software.
It's in private preview for select Enterprise customers. Lovable says some features available on its own hosting aren't there yet.
Deutsche Telekom is the launch customer. It went live in October with its apps in its own AWS account.
What runs where under Deploy on AWS:
How it works: An admin creates a new Enterprise workspace and chooses to host it in AWS. Lovable generates a CloudFormation stack, and your team reviews and runs it. A runner on EC2 then sets up EKS, Aurora, and S3.
Lovable installs and updates everything it deploys, using separate IAM roles for setup, maintenance, and decommissioning.
Data protection: The components in your account connect out to Lovable over an mTLS-encrypted tunnel. Lovable never needs an inbound connection.
Chat and project history are encrypted at rest. Admins can connect their own AWS KMS key and revoke Lovable's access.
Your Enterprise controls apply too, including SSO and SCIM, publishing limited to workspace members by default, a security scan on every build, and audit logs. Our Lovable Enterprise review covers the plan.
The Lovable Azure option
Deploy on Azure is the Lovable Azure equivalent, announced October 15, 2026, also in private preview. It runs the data plane on AKS, published apps on Azure Blob Storage and Azure Functions, and the database on Azure Database for PostgreSQL.
The editor and agent stay with Lovable.
Lovable lists two other Microsoft options. Copilot Managed Runtime is a public preview where Microsoft hosts the app in your tenant, and the second option is hosting on Lovable with Microsoft connectors.
Is there a Lovable on premise option?
No. Lovable on premise isn't offered for the editor or agent. Deploy on AWS and Azure run apps and data in your cloud accounts, and exported apps can run on your own servers.
Lovable on AWS vs. Superblocks Managed BYOC
Under Deploy on AWS, the editor, the agent, and AI requests stay in Lovable's cloud. A platform that runs entirely in your account closes that gap. Superblocks, the governed enterprise vibe coding platform, offers that through Managed BYOC (previously Cloud-Prem).
Lovable on AWS and Superblocks Managed BYOC side by side:
Sources: Lovable's Deploy on AWS post, Superblocks' deployment overview, and the Managed BYOC docs. On databases, Lovable's environments guide says it retired its separate Test and Live environments on October 23, 2026. Every project now uses a single database.
Security checks differ too. Lovable runs a Quick scan automatically when you publish, with a Deep scan on demand and scheduled deep scans on Enterprise.
Whether findings block publishing depends on the workspace's publishing controls. Admins can turn on Block publishing with critical issues. New Enterprise workspaces start with it enabled.
Superblocks tests every code change with security agents and scanners. It continuously scans deployed dependencies for newly disclosed vulnerabilities. A private package registry restricts where packages come from.
Our Lovable vulnerability guide covers a row-level security flaw that exposed data in 170+ Lovable-built apps.
Clark's inference can run on Amazon Bedrock in your account, on models and regions you control. Each app gets its own Aurora PostgreSQL database, with secrets kept in AWS Secrets Manager.
Existing Lovable apps can come over with App Imports. Upload a zip of your project and Clark handles the rest. It maps database clients, including Supabase, and Supabase Auth to platform equivalents.
See the App Imports announcement and our Lovable migration guide.
Managed BYOC has limits. Superblocks is built for internal apps, and Managed BYOC runs on AWS. SSO, audit logs, and VPC deployment are Enterprise features.
See where the editor and the agent run. Book a demo to see Managed BYOC running entirely in an AWS account.
Self hosted Lovable alternative: open source and in-account options
Three options let you run the builder itself. They don't match Lovable's hosted experience, and you still host and govern the apps.
Three alternatives to consider:
- Dyad: An open source Lovable alternative, a local desktop app that uses your own API keys. Most of its code is Apache 2.0, and it doesn't host your app.
- bolt.diy: An open-source, AI-powered web development tool that you run yourself with Node.js or Docker.
- Superblocks Managed BYOC: A governed platform that runs in your AWS account, built for internal apps.
For more options, see our guide to the best Lovable alternatives.
Where does Lovable host your data?
Lovable's own infrastructure holds your data by default. Published apps are served from locations worldwide, and the built-in backend data lives in the region chosen when you enable the backend.
Chat and project history stay in Lovable's service. Business and Enterprise workspace admins can set a default region, and Deploy on AWS or Azure moves app data into your own cloud account.
Common mistakes to avoid
Five mistakes that break a Lovable move:
- Assuming the export includes your data: Git sync and the zip carry code only. Export the database and files separately.
- Hosting a TanStack Start app as static files: It needs a host that runs server code.
- Moving only the Postgres database: Authentication, storage, realtime, and Edge Functions don't come with it.
- Forgetting redirect URLs: Sign-in breaks until the new URL is in your auth provider's allowed list.
- Removing the backend too early: Download and verify your exports first.
My verdict on running Lovable apps yourself
Self-hosting a Lovable app works. The effort sits in the backend migration and the TanStack Start versus React and Vite split. Keep Lovable for building, and move the app when a compliance rule requires it.
If your rule also covers the editor, the agent, and AI requests, Deploy on AWS leaves those with Lovable. Only a platform that runs entirely in your account moves them.
Frequently asked questions
Is Lovable a hosting service?
Lovable is partly a hosting service. Publishing puts your app on a lovable.app URL with HTTPS, free on all plans, and custom domains need a paid plan. It isn't a separate hosting product, and you can host the apps elsewhere.
How does Lovable work?
Lovable works from a chat. You describe an app, Lovable's AI agent writes the code, and you see a live preview. You publish when it's ready. Lovable also provides a built-in backend with a database, authentication, and storage, and it syncs your code to GitHub.
How do I connect a custom domain to Lovable?
Connect a custom domain to Lovable by publishing first, then opening Project, Settings, Domains, and choosing Connect existing domain. Add the A record and the verification TXT record Lovable shows at your DNS provider. Custom domains need a paid plan, and DNS can take up to 72 hours.
How do I deploy a Lovable app?
Deploy a Lovable app by clicking Publish. That puts it on a lovable.app URL. To deploy elsewhere, sync the project to GitHub and check whether it's TanStack Start or React and Vite.
Then set your environment variables and deploy to a host such as Vercel or Netlify.
Where does Lovable host your data?
Lovable hosts your data on its own infrastructure by default. The backend's data lives in the region chosen when the backend was enabled, and Lovable stores chat and project history. Deploy on AWS or Azure in private preview; runs app data in your own account.
Do I need Docker to self-host a Lovable app?
You don't need Docker to self-host a Lovable app. Lovable lists containers alongside Kubernetes clusters and virtual machines as one option. Managed hosts such as Vercel, Netlify, and Cloudflare Pages deploy straight from your repository.
Can I self-host Lovable?
You can self-host the apps Lovable builds, but not the editor or AI agent. Lovable says the editor and agent can't be self-hosted or deployed inside a customer VPC. Deploy on AWS and Azure are private previews for Enterprise customers.
Stay tuned for updates
Get the latest Superblocks news and internal tooling market insights.
Request early access
Step 1 of 2
Request early access
Step 2 of 2
You’ve been added to the waitlist!
Book a demo to skip the waitlist
Thank you for your interest!
A member of our team will be in touch soon to schedule a demo.
production apps built
days to build them
semi-technical builders
traditional developers
high-impact solutions shipped
training to get builders productive
SQL experience required
See the full Virgin Voyages customer story, including the apps they built and how their teams use them.

"Those tools are great for proof of concept. But they don't connect well to existing enterprise data sources, and they don't have the governance guardrails that IT requires for production use."
Table of Contents

