Cómo alojar una app de Lovable en un VPS con Coolify

Para alojar una app de Lovable en un VPS con Coolify, instale Coolify en un servidor Linux, conecte el repositorio de GitHub con una GitHub App y elija el build: Nixpacks con salida estática en /dist o un Dockerfile. Después, cargue las variables VITE_ como variables de build, apunte el dominio con https:// y active el deploy en cada push.

Recomendación de Heartscale: haga el primer deploy en un subdominio de prueba y revise el inicio de sesión, la escritura y la recarga de rutas internas antes de apuntar el dominio de producción. Si la app tiene usuarios reales, pagos o datos personales, pida una revisión de variables y secretos antes de cambiar el DNS.

Esta guía cubre solo el alojamiento. Si todavía necesita sacar el código y la base de datos de Lovable, empiece por Cómo salir de Lovable y vuelva aquí en el paso del servidor.

Qué necesita antes de empezar

• Un VPS con Linux. Coolify pide 2 núcleos de CPU, 2 GB de RAM y 10 GB de disco, con acceso root o sudo por SSH (Coolify, Installation). La documentación recomienda un servidor nuevo.
• Un dominio cuyo DNS usted pueda editar.
• El código en GitHub. En Lovable, el camino es el Git sync en Project settings → Git (Lovable, GitHub).
• Saber el stack del proyecto. Abra el package.json. Si incluye @tanstack/react-start, es TanStack Start y necesita un servidor Node. Si no, es React + Vite y el build genera archivos estáticos en dist/ (Lovable, Deploying outside Lovable).

Paso 1: instale Coolify

Entre al VPS por SSH y ejecute el instalador oficial:

curl -fsSL https://cdn.coollabs.io/coolify/install.sh | bash

Si Docker se instaló con snap, quítelo antes. En Ubuntu, use una versión LTS: 20.04, 22.04 o 24.04.

Al terminar, la terminal muestra el enlace del panel, en http://<ip-del-servidor>:8000. Cree la cuenta de administrador de inmediato. La documentación advierte que quien llegue primero a la página de registro se vuelve administrador y obtiene acceso root al servidor.

Abra en el firewall los puertos que usa Coolify (Coolify, Firewall):

Puerto	Para qué
22	SSH
80	HTTP y emisión del certificado
443	HTTPS
8000	Panel por IP
6001 y 6002	Actualización en tiempo real y terminal del panel por IP

Cuando el panel abra por un dominio, puede cerrar 8000, 6001 y 6002.

Guarde una copia del archivo /data/coolify/source/.env. Contiene la APP_KEY, que cifra los datos de Coolify y es necesaria para restaurar la instalación.

Paso 2: conecte GitHub con una GitHub App

El repositorio que crea Lovable es privado por defecto. Para repositorios privados con eventos de push, Coolify indica la GitHub App (Coolify, GitHub App):

1. En el panel, abra Sources y elija GitHub App.
2. Póngale un nombre a la fuente. Deje Organization vacío si el repositorio está en su cuenta personal.
3. Haga clic en Register with GitHub, dé un nombre único a la app en GitHub y confirme con Create GitHub App.
4. En Install repositories, elija Only select repositories y marque solo el repositorio de la app.

Dar acceso a un solo repositorio limita lo que Coolify ve en su cuenta.

Paso 3: cree la aplicación

1. Abra el proyecto y el entorno en Coolify y haga clic en + New.
2. Elija Private Repository (with GitHub App).
3. Seleccione el servidor. En una instalación propia aparece como localhost.
4. Elija la fuente del paso 2, el repositorio y haga clic en Load Repository.
5. Elija la rama que sincroniza Lovable, por lo general main.

El siguiente campo es Build pack. Define cómo el código se convierte en sitio.

Paso 4: elija el build

React + Vite con Nixpacks

Es el camino con menos archivos nuevos. Nixpacks detecta el proyecto Node y genera la imagen solo (Coolify, Nixpacks):

1. En Build pack, elija Nixpacks. Deje Base Directory en /.
2. En Output type, elija Static site y complete Publish Directory con /dist.
3. Mantenga el puerto 80. Ahí escucha el Nginx generado.
4. Después de crearla, en General → Build pipeline → Site type, elija SPA.
5. Revise en General los campos Install Command, Build Command y Start Command. Cambie solo lo que venga mal detectado.

Lovable compila con Node 22. Nixpacks lee la versión de engines.node en el package.json, del .nvmrc o de la variable NIXPACKS_NODE_VERSION.

React + Vite con Dockerfile

Use este camino si quiere controlar la imagen. Lovable sugiere dos etapas: node:22-alpine para compilar y nginx:alpine para servir dist/ (Lovable, Deploying outside Lovable). Un ejemplo con esa forma:

FROM node:22-alpine AS build
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
ARG VITE_SUPABASE_URL
ARG VITE_SUPABASE_PUBLISHABLE_KEY
ARG VITE_SUPABASE_PROJECT_ID
RUN npm run build

FROM nginx:alpine
COPY --from=build /app/dist /usr/share/nginx/html
COPY nginx.conf /etc/nginx/conf.d/default.conf
EXPOSE 80

Y el nginx.conf al lado, con el fallback de SPA:

server {
  listen 80;
  root /usr/share/nginx/html;
  location / {
    try_files $uri $uri/ /index.html;
  }
}

En Coolify, elija Dockerfile en Build pack y complete Ports Exposes con 80 (Coolify, Dockerfile). Coolify pasa las variables de build como argumentos de Docker, por eso el Dockerfile declara los ARG. Lovable advierte que no ejecuta ni prueba builds de Docker: pruébelo usted.

TanStack Start

Los proyectos creados en Lovable desde el 13/05/2026 usan TanStack Start y necesitan un servidor Node corriendo. El build usa NITRO_PRESET=node-server npm run build y el servidor arranca con node .output/server/index.mjs, en el puerto 3000. En Coolify, deje el puerto interno en 3000. El proceso tiene que escuchar en 0.0.0.0 para que el proxy lo alcance: defina HOST=0.0.0.0. Aquí no hay fallback de SPA, porque las rutas las maneja el servidor.

Paso 5: configure las variables VITE_

Las variables con prefijo VITE_ se incorporan al código en el build. En un proyecto de Lovable son VITE_SUPABASE_URL, VITE_SUPABASE_PUBLISHABLE_KEY y VITE_SUPABASE_PROJECT_ID, con los valores del .env del proyecto.

En Coolify (Coolify, Environment variables):

1. Abra la aplicación y haga clic en Environment Variables.
2. Haga clic en Add, complete Name y Value y guarde con Add variable. También puede pegar el .env completo en la vista Developer.
3. Para las VITE_, deje Build time en Available during build.

¿Cambió el valor de una VITE_? Haga un deploy nuevo. Restart solo aplica variables de runtime.

Todo lo que lleva VITE_ termina en el navegador de cualquier visitante. Los secretos de pago, correo o IA nunca llevan ese prefijo. En TanStack Start, los secretos de las funciones de servidor quedan como variables de runtime, con Build time en Not available during build.

En nuestras revisiones, antes del primer deploy, listamos cada variable y revisamos si alguna con prefijo VITE_ guarda un secreto. Después del build, buscamos esos valores en los archivos de dist/ para confirmar qué llega al navegador.

Paso 6: apunte el dominio y active el HTTPS

1. En el DNS del dominio, apunte la dirección a la IP del VPS. Si va a usar www y el dominio sin www, cree los dos registros.
2. En Coolify, abra Domains y haga clic en Add domain.
3. En Protocol, elija https. En Domain, escriba la dirección, por ejemplo app.sudominio.com.
4. Registre cada dirección por separado. Para dejar una como principal, use la opción www redirect (Redirect to www o Redirect to non-www).
5. Haga un deploy nuevo para que el proxy aplique la configuración.

Con https:// y los puertos 80 y 443 abiertos, el proxy de Coolify pide y renueva el certificado (Coolify, Domains).

Después, en la configuración de login de la app, agregue la URL nueva a la lista de URLs de retorno. Sin eso, el inicio de sesión falla en el dominio nuevo.

Paso 7: deploy en cada push

Las aplicaciones creadas con una GitHub App ya traen Auto deploy en Deploy on push (webhooks) (Coolify, Auto deploy). Si aparece Manual deployments only, cámbielo en Advanced → Deployment. Luego haga un push a la rama y confirme que aparece el deploy.

El Git sync de Lovable escribe en la rama conectada. Por eso cada cambio hecho en el chat de Lovable también se publica. Si quiere revisar antes, haga el deploy manual o apunte Coolify a otra rama y una los cambios por pull request.

Paso 8: pruebe el fallback de SPA

Abra una ruta interna directo por la dirección, por ejemplo /panel, y recargue. Si da 404, falta el fallback al index.html.

Con Nixpacks, vaya a General → Build pipeline → Custom Nginx configuration, agregue try_files $uri $uri/ /index.html; en el bloque location / y haga un deploy nuevo. Un restart no aplica el cambio, porque la configuración entra en la imagen durante el build.

Haga también las otras pruebas de la documentación de Lovable: iniciar y cerrar sesión, leer, guardar y subir un archivo.

Qué pasa a ser suyo

Fuera de Lovable, usted se encarga de certificados, backups, control de acceso, monitoreo y auditorías de seguridad (Lovable, Deployment, hosting and ownership). Tres puntos de Coolify:

• Backup de la instalación. Guarde /data/coolify/source/.env fuera del servidor. La documentación pide un backup antes de cada actualización.
• Actualizaciones. En Settings → Updates, Automatic updates mantiene Coolify al día. No actualiza las apps, las bases ni los servidores que Coolify administra (Coolify, Upgrade).
• La dirección anterior. La URL lovable.app sigue sirviendo la última versión publicada allí, y Publish publica solo en Lovable.

Para calcular cuánto cuesta esto por mes, lea Cuánto cuesta mantener una app de Lovable en línea y nuestra página de deploy en servidor propio.

¿Hacerlo usted mismo o contratar?

Si usted ya usa SSH y DNS, la instalación es la parte sencilla. Lo que pesa es lo que asume después.

Situación	Camino
Proyecto React + Vite sin secretos en el front, y alguien del equipo usa SSH y DNS	Hágalo usted mismo con esta guía
Usuarios reales que inician sesión con Google u otro proveedor	Conviene llamar a un equipo: dominio, HTTPS y URLs de retorno deben cambiar juntos
Secretos de pago, correo o IA, o TanStack Start con funciones de servidor	Conviene llamar a un equipo como el nuestro: un error al separar variables de build y de runtime deja la clave en el navegador
Nadie técnico para mantener el servidor, los backups y las actualizaciones	Solicite el diagnóstico de Heartscale antes de contratar el VPS: muestra qué usa su app de Lovable y qué necesita ajuste para correr afuera

Solicite un diagnóstico de Heartscale

Nuestro equipo revisa el stack de su app, arma el build en Coolify, separa las variables de build de los secretos y deja funcionando HTTPS, dominio y deploy en cada push. Antes, el diagnóstico muestra qué usa su app de Lovable y qué necesita ajuste para correr afuera.

El diagnóstico, a precio de lanzamiento, cuesta US$ 19 (antes US$ 79) y se descuenta si contrata el deploy. Solo trabajamos en apps de quien demuestra ser su dueño.

Solicitar el diagnóstico