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 your code.
    All Lovable projects can be continuously synced to GitHub or GitLab at any time using Git sync. You can clone your repository, modify it outside Lovable, deploy it on your own infrastructure, or fully self-host without restriction.
  • 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.
    Everything runs on open standards and open-source technologies. Applications are standard Vite + React projects that can run on major cloud providers (AWS, GCP, Azure), managed hosting platforms, or self-hosted infrastructure. No proprietary frameworks, no hidden dependencies.
  • We earn your trust through quality, not control.
    Lovable hosting is optimized for speed, simplicity, and reliability. If your requirements change, you can move without friction. 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

Lovable applications are standard Vite + React projects built on open-source technologies. The frontend can be deployed to infrastructures that support Node.js builds and static file hosting, including:
  • 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
If your project uses the built-in backend (Cloud), it can stay there while you host the frontend anywhere. Moving frontend hosting does not require architectural changes. If you need to move your backend, we support migrating to managed Supabase and self-hosted Supabase. Some built-in backend features aren’t available on an external backend. While the underlying database is PostgreSQL, Lovable applications rely on Supabase-specific services such as authentication, storage, realtime, and edge functions. Migration to plain PostgreSQL or other database providers would require implementing equivalent authentication, storage, and edge services and is not supported out of the box.

​
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 (GitHub or GitLab) 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 (GitHub or GitLab). 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 edge cases, not the default path. If you’re unsure, start with Lovable. You can always move later without rebuilding. For practical examples and deployment instructions, see Deploying and hosting outside Lovable.