Skip to main content
Lovable is designed to be the easiest, fastest, and most enjoyable way to build production-ready applications. It provides a high-quality AI agent, a visual editor, preview environments, and fully managed infrastructure so you can focus on building, not operating systems. For what that hosting means in practice, see How Lovable hosts your app. Lovable is intentionally built so that you are never locked in. You can export your code, migrate your data, self-host parts or all of your stack, or move to another provider at any time. We want you to stay with Lovable by choice, never by necessity.

​
Key principles

  • You own what you create.
    Your apps, code, and content you create with Lovable are yours, subject to third-party rights such as open-source licenses. You can modify them, use them commercially, and host them wherever you choose. See the Terms of Service. Use Git sync to keep your code in your own repository.
  • You own your data.
    Your database, storage, and configuration are portable. You can export schemas and data, migrate to another provider, or run everything on infrastructure you control. Lovable does not rely on proprietary data stores.
  • Lovable is built on open source technologies.
    Lovable apps are built on open-source frameworks. New apps created from May 13, 2026 use TanStack Start, which runs server code. Older apps use React + Vite and build to static files. You can deploy either to managed hosting or infrastructure you control. Your backend, AI, and connectors are separate services that you keep, reconfigure, or replace when you move.
  • We earn your trust through quality, not control.
    Lovable hosting is optimized for speed, simplicity, and reliability. If your requirements change, you can move your code and migrate the services your app uses. That freedom is intentional.

​
What you get with Lovable hosting

While Lovable is designed to work with many hosting and infrastructure setups, Lovable’s own hosting and built-in backend (Cloud) are where the platform delivers the most value, especially during active development and iteration. When you host on Lovable, development, previews, and production operate together in one integrated environment. You focus on building. We handle the platform. Running your app on Lovable provides:
  • AI-assisted development tightly integrated with your application
  • Visual editing and real-time preview environments
  • Production hosting with custom domains, automatic SSL, and global delivery
  • Automatic deployments and environment management
  • Fully managed backend, databases, and infrastructure
  • Built-in authentication and data isolation
  • Integrated integrations and secrets management
  • Managed AI provider access for runtime features
  • Automated security scanning and compliance-ready infrastructure (SOC 2 Type 2 and ISO 27001 certified)
  • Minimal operational overhead

​
What changes if you stop using Lovable

If you stop using Lovable entirely (editor, agent, previews, and hosting), Lovable no longer manages your development and deployment workflow. You will be responsible for:
  • Configuring and maintaining development environments and debugging workflows
  • Building and managing CI/CD pipelines and release processes
  • Operating production infrastructure, SSL certificates, CDN configuration, and scaling
  • Running databases, storage systems, backups, and access controls
  • Implementing authentication and enforcing data isolation policies
  • Managing OAuth flows, secrets, and external API integrations
  • Managing AI provider accounts, credentials, billing, and rate limits
  • Maintaining security audits, monitoring, and compliance posture
This is simply the operational boundary of moving off a fully managed platform.

​
How Lovable fits into your stack

Applications built with Lovable consist of three independent parts: Lovable can host both the frontend and backend, but you can move either part independently to managed platforms or your own infrastructure.

​
Lovable platform compatibility

Older React + Vite apps build to static files that any static host can serve. TanStack Start apps run server code, such as server-side rendering, server functions, and API routes, so they need a host that runs the server part as well as serving the static files. Follow TanStack Start’s hosting guide for the supported providers. For older Vite apps, hosting options include:
  • Amazon Web Services (AWS):
    Static hosting + CDN (S3 + CloudFront), container services (ECS), managed Kubernetes (EKS), application hosting (Amplify)
  • Google Cloud Platform (GCP):
    Static hosting + CDN (Cloud Storage + Cloud CDN), container services (Cloud Run), managed Kubernetes (GKE)
  • Microsoft Azure:
    Static site hosting (Static Web Apps), container services (Azure Container Apps), managed Kubernetes (AKS)
  • Self-hosted infrastructure:
    Containers (Docker), Kubernetes clusters, virtual machines running Nginx or Apache
  • Managed frontend hosting platforms:
    Netlify, Cloudflare Pages, Vercel
Your built-in backend (Cloud) can stay in place while you move the frontend to another provider. Configure the new host’s environment variables, server secrets, and sign-in redirect URLs for the services your app continues to use. If you move the built-in backend (Cloud), the supported destinations are managed Supabase and self-hosted Supabase. Other backends need changes to your app’s integration code, and some built-in backend features need replacements. Moving the PostgreSQL database alone does not move authentication, storage, realtime, or Edge Functions. Migrating to plain PostgreSQL or another database provider means implementing equivalents yourself, and Lovable does not support it.

​
Common deployment and hosting setups

Most people end up in one of these configurations:
  • Preview and production hosted on Lovable
  • Backend and frontend fully managed by Lovable
  • Custom domains fully supported
  • No infrastructure setup or maintenance required
Best for most applications.

​
Lovable + managed platforms (hybrid)

  • Lovable used for development, previews, and tooling
  • One or more production components deployed to managed services:
    • Managed backend (for example, managed Supabase, or cloud-managed PostgreSQL combined with your own authentication, storage, and backend services)
    • Managed frontend hosting platforms (for example, Cloudflare Pages, Netlify, or cloud-provider static hosting)
  • Your Git provider used as the bridge between Lovable and production
Best for those with specific backend or compliance requirements.

​
Fully self-managed infrastructure (advanced)

  • Code synced via Git sync
  • Backend services and database run on infrastructure you operate (for example, self-hosted Supabase, or managed PostgreSQL combined with your own authentication, storage, and edge services)
  • Frontend deployed via containers, VMs, or internal platforms
  • Lovable may still be used for development, or development can fully move to other tools
The Lovable platform itself (the editor and AI agent) is a managed service and cannot be self-hosted or deployed inside a customer VPC.

The applications you build with Lovable can be hosted anywhere.

​
Setup comparison

You do not need to decide everything upfront. Lovable lets you start simple and move incrementally as requirements change. The recommended path:
  1. Start on Lovable. This is the fastest path to production with minimal operational overhead.
  2. Sync your code with Git sync. This ensures code ownership and enables external collaboration.
  3. Move components only when you hit a real constraint, not a hypothetical one.
For most applications, hosting on Lovable is the most efficient and reliable option. Consider moving parts of your stack only if you have specific requirements that Lovable cannot meet:
  • Compliance or data residency mandates tied to specific infrastructure providers
  • Networking configurations not supported by Lovable (for example, VPC peering, private endpoints)
  • Organizational policies requiring self-managed or audited hosting environments
These are exceptions, not the default path. If you’re unsure, start with Lovable. Your code stays yours, so you can move later and adapt the deployment and the services your app uses. For practical examples and deployment instructions, see Deploying and hosting outside Lovable.