Lovable Self Hosted: 3 Ways to Run Apps in Your Cloud

Superblocks Team
+2

Multiple authors

November 17, 2026

0 min read

Copied
0:00

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:

🧩 Part 🏠 Can you self-host it? 📝 What Lovable says
Code and frontend Yes Host it on managed platforms, containers, or virtual machines
Backend and data Yes, with work Managed or self-hosted Supabase are the supported destinations
Editor and AI agent No A managed service that can't be self-hosted or deployed inside a customer VPC

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 🖥️ What runs in your cloud ☁️ What stays with Lovable ✅ Availability
1. Export and self-host The app, and optionally its backend The editor and agent, if you keep building in Lovable Now, with Git sync on all plans (docs)
2. Lovable Deploy on AWS Preview sandboxes, published apps, the app database, and storage The editor, agent, chat and project history, settings, identity, and billing Private preview for select Enterprise customers
3. A platform that runs in your account The whole platform, including the editor and agent Nothing Generally available (Superblocks Managed BYOC)

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:

🏗️ Stack 📦 What you deploy 🖥️ What the host needs
TanStack Start (apps created from May 13, 2026) Server output and static assets A host that runs server code, including server-side rendering, server functions, and API routes
Older React + Vite Static files in dist/ A static host or CDN, with a fallback to index.html for client-side routes

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:

📦 Piece 🔧 How it moves
Schema and policies Apply the migration files that define the database structure
Table data Request a database export (More, Database, Manage, Settings). It's a compressed PostgreSQL archive, restored with pg_restore
User accounts They come with the export, including their password hashes
Storage files Download them from More, Storage, and upload them manually
Secrets, sign-in provider settings, and API keys The export leaves them out. Recreate them at the new destination
Edge Functions The export leaves out their code. Deploy it with the Supabase CLI

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:

🏠 Host 🏗️ TanStack Start (server) 📄 React + Vite (static) 🗄️ Backend you still need 🛠️ Setup effort 👤 Who operates it
Vercel Yes, detected automatically Yes Lovable's built-in backend or Supabase Low Vercel
Netlify Yes, detected automatically Yes Lovable's built-in backend or Supabase Low Netlify
Cloudflare Pages Yes, detected automatically Yes Lovable's built-in backend or Supabase Low Cloudflare
Coolify on a VPS Yes, through a Node container (my reading) Yes, through a static container Lovable's built-in backend or Supabase Medium You
Container or Node host (ECS, Kubernetes, a VM) Yes, with the Node server build Yes, with Nginx Lovable's built-in backend or Supabase Medium to high You
AWS S3 and CloudFront No, because object storage and a CDN don't run the server Yes, with a CI pipeline and a routing fallback Lovable's built-in backend or Supabase Medium You
AWS Amplify Hosting Not stated in Lovable's docs Yes Lovable's built-in backend or Supabase Low AWS

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:

🏢 What runs in your AWS account ☁️ What stays in Lovable's multi-tenant service
A dedicated VPC The editor
The Lovable data plane on Amazon EKS, including the preview sandboxes where builds run The agent
Published apps, with static files in S3 and dynamic requests on Lambda Chat and project history
The app database on Aurora PostgreSQL, and app storage in S3 Workspace settings, identity, and billing
Application logs, sendable to S3 or CloudWatch AI model requests made while building, which Lovable's AI service still processes
The connector gateway and your integration secrets, with VPC peering to internal systems ㅤ

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:

🧩 Feature 💜 Lovable on AWS 🧱 Superblocks Managed BYOC
Status Private preview Generally available
Clouds AWS, Azure AWS
Editor, agent, and settings Lovable's cloud Your AWS account
Separate dev and production databases No, one per app Yes, every app
Build environment Your VPC Your AWS account
Deployed apps Your VPC Your AWS account
App database Your VPC Your AWS account
Who operates it Lovable Superblocks

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.

You've successfully signed up

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.

8

production apps built

30

days to build them

10

semi-technical builders

0

traditional developers

8+

high-impact solutions shipped

2 days

training to get builders productive

0

SQL experience required

See full story →

See the full Virgin Voyages customer story, including the apps they built and how their teams use them.

Large cruise ship sailing in a harbor with a road lined with palm trees and cars in the foreground.
Why not Replit, Lovable, or Base44?

"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."

Superblocks Team
+2

Multiple authors

Nov 17, 2026