n8n Self-Hosted

2.1. ¿Qué es n8n y Por Qué Self-Hosted?

n8n es una plataforma de automatización visual que conecta aplicaciones mediante nodos. Cada nodo hace una acción: leer un email, consultar una API, enviar un mensaje, transformar datos.

Comparativa de modelos de negocio (la decisión económica para el PM):

Por qué self-hosted es la decisión correcta para un PM:

1. Sin límites artificiales. Tu workflow puede tener 50 pasos sin que el precio cambie.
2. Tus datos no salen de tu red. Clientes de consultoría con datos sensibles no deberían pasar por servidores de terceros.
3. Puedes experimentar sin pedir presupuesto. Abres tu laptop, instalas Docker, y estás corriendo en 15 minutos. Sin tarjeta de crédito.
4. Escala contigo. Cuando el workflow crece, migras a un servidor dedicado. El mismo software.

2.2. ¿Qué es Docker? (La Explicación que un PM Necesita)

Docker es una plataforma que empaqueta software en "contenedores".

Conceptos clave para entender los comandos:

¿Por qué debería importarle a un PM?

Porque Docker es el estándar de la industria para desplegar software. Cuando le pidas a tu equipo de ingeniería que te ayude a poner n8n en un servidor, te van a pedir "un Dockerfile" o "un docker-compose.yml". Saber leer ese archivo y entender qué hace cada línea te da credibilidad técnica sin necesidad de saber programar.

Además, Docker te permite probar herramientas como si fueran apps en tu celular: descargas, pruebas, y si no te gustan, las borras sin ensuciar tu computadora. Quieres probar Supabase, Metabase, Airbyte, o cualquier herramienta open-source? Casi siempre hay un docker compose up -d y en 2 minutos la tienes corriendo.

Para instalar n8n con Docker, solo necesitas estos 3 movimientos:

docker pull n8nio/n8n      # Descargar la imagen de n8n
docker run ...             # Crear y ejecutar el contenedor
docker compose up -d       # La forma correcta con persistencia de datos

No necesitas ser ingeniero para esto. Solo copiar, pegar, y ejecutar. Lo que sigue es el paso a paso exacto.

2.3. Anatomía de un Workflow en n8n

2.4. El Caso de Uso: Enriquecimiento de Leads para Consultoría

Una consultora recibe leads desde un formulario web. Cada lead necesita:

1. Ser enriquecido con datos públicos (LinkedIn, web de la empresa).
2. Categorizado según industria y tamaño (Small/Medium/Enterprise).
3. Asignado a un vendedor específico según categoría.
4. Registrado en el CRM.
5. Notificado al equipo en Slack.

1. Instalar Docker (lo que el PM necesita)

   Docker Desktop es una aplicación que corre en tu computadora y gestiona los contenedores. Piensa en ella como el "panel de control" de tus contenedores: puedes ver cuáles están corriendo, cuánta memoria usan, y encenderlos/apagarlos con un clic.

   Requisitos del sistema (verifica antes de empezar)

   • Windows: 8 GB RAM mínimo (16 GB ideal), WSL 2 habilitado
   • macOS: Apple Silicon (M1/M2/M3) o Intel, 4 GB RAM mínimo
   • Linux: 2 GB RAM mínimo
   • Espacio en disco: ~3 GB libres

   Windows

   1. Pre-requisito: habilita WSL 2. Abre PowerShell como administrador y ejecuta:

      # Habilita el subsistema de Linux
      wsl --install
      
      # Configura WSL 2 como versión predeterminada
      wsl --set-default-version 2
      

      Esto instala un kernel de Linux ligero dentro de Windows. Docker lo necesita para correr contenedores de forma eficiente (más rápido que Hyper-V y con menos memoria).
   2. Descargar e instalar: ve a docker.com/products/docker-desktop/ y descarga el instalador para Windows.
   3. Durante la instalación: marca "Use WSL 2 instead of Hyper-V" si te lo pregunta.
   4. Abrir Docker Desktop: búscalo en el menú Inicio y ábrelo. Acepta los términos. Si ves "Docker Desktop is running" y el ícono de la ballena en la barra de tareas, Docker está activo.
   5. Verificar con PowerShell: docker --version — deberías ver Docker version 27.x.x, build xxxxx.
   ✓

   Problema común

   Si docker --version no se reconoce, cierra y vuelve a abrir tu terminal: necesitas una sesión nueva para que el PATH se actualice.

   macOS

   1. Descarga Docker Desktop desde docker.com (versión Apple Silicon si tienes M1/M2/M3, Intel si tienes Mac antiguo).
   2. Arrastra la aplicación a la carpeta Applications y ábrela.
   3. Acepta los términos de servicio. Espera a que la ballena aparezca en la barra de menú.
   4. Verifica en terminal: bash docker --version

   Linux (Ubuntu/Debian)

   En Linux no usas Docker Desktop. Usas la versión nativa (más ligera):

   # Actualiza la lista de paquetes
   sudo apt update
   
   # Instala Docker Engine y Compose
   sudo apt install docker.io docker-compose-v2
   
   # Habilita Docker para que arranque automáticamente al prender el equipo
   sudo systemctl enable --now docker
   
   # Agrega tu usuario al grupo docker (para no tener que usar sudo en cada comando)
   sudo usermod -aG docker $USER
   
   # Cierra sesión y vuelve a entrar, o ejecuta:
   newgrp docker
   
   # Verifica
   docker --version
   

2. ¿Qué es Docker Compose y por qué usarlo?

   Docker Compose te permite definir y ejecutar múltiples contenedores con un solo archivo. En lugar de escribir comandos largos cada vez, escribes un docker-compose.yml con toda la configuración y ejecutas docker compose up -d.

   ¿Por qué es mejor que docker run?

   • Reproducible: el archivo YAML es tu "receta". Lo compartes con un compañero y obtiene exactamente la misma configuración.
   • Persistente: los datos se guardan en una carpeta local. Si el contenedor se cae o lo borras, tus workflows sobreviven.
   • Portable: el mismo archivo funciona en tu laptop y en un servidor en la nube sin cambios.
3. Instalar n8n con Docker Compose

   Crea una carpeta para n8n (por ejemplo C:\n8n en Windows o ~/n8n en Mac/Linux) y dentro de ella crea un archivo docker-compose.yml:

   # docker-compose.yml
   # Este archivo le dice a Docker cómo ejecutar n8n con persistencia de datos
   version: "3.8"
   
   services:
     n8n:
       image: n8nio/n8n             # La imagen oficial de n8n (qué programa correr)
       container_name: n8n           # El nombre del contenedor (para referirte a él)
       restart: unless-stopped       # Política de reinicio automático
       ports:
         - "5678:5678"               # Mapeo de puertos: [tuPC:contenedor]
       volumes:
         - ./n8n-data:/home/node/.n8n  # Persistencia de datos: [carpetaLocal:carpetaContenedor]
       environment:
         - N8N_SECURE_COOKIE=false     # Desactivado para uso local (HTTP, no HTTPS)
         - N8N_METRICS=false           # Desactiva métricas innecesarias
         - N8N_SKIP_WEBHOOK_DEREGISTRATION_ON_SHUTDOWN=true  # Mantiene webhooks al reiniciar
   

   Qué hace cada línea explicado para un PM:

   Línea	¿Qué significa?	¿Qué pasa si la cambias o la quitas?
   image: n8nio/n8n	Le dice a Docker: "descarga el programa n8n de la tienda oficial"	Si la cambias por otra imagen (ej. n8nio/n8n:2.0), obtienes una versión específica
   container_name: n8n	Le pone nombre al contenedor para identificarlo fácilmente	Si no la pones, Docker le asigna un nombre aleatorio como n8n_xyz123
   restart: unless-stopped	"Si n8n se cae, reinícialo automáticamente, a menos que yo lo detenga explícitamente"	Sin esto, si tu compu se reinicia, n8n queda apagado y tienes que iniciarlo manual
   ports: "5678:5678"	"Todo lo que entre al puerto 5678 de tu compu, pásalo al puerto 5678 del contenedor donde n8n está escuchando"	Si cambias el puerto izquierdo a 8080:5678, accedes a n8n en http://localhost:8080
   volumes: ./n8n-data:/home/node/.n8n	"Crea un vínculo entre la carpeta ./n8n-data de tu compu y la carpeta interna de n8n donde guarda sus datos"	Sin esto, si borras el contenedor, pierdes todos tus workflows y configuraciones
   N8N_SECURE_COOKIE=false	"No exijas HTTPS para las cookies de sesión"	En producción deberías ponerlo en true, pero en local sin HTTPS no funciona

   Guarda el archivo docker-compose.yml y en la terminal (asegúrate de estar en la misma carpeta donde lo guardaste):

   # Crea la carpeta donde n8n guardará sus datos (tu "sótano")
   mkdir n8n-data
   
   # Inicia n8n en segundo plano (-d = "detached", se ejecuta sin bloquear la terminal)
   docker compose up -d
   

   ¿Qué acaba de pasar?

   1. Docker descargó la imagen de n8n (la primera vez toma ~1 minuto).
   2. Docker creó un contenedor a partir de esa imagen.
   3. Docker vinculó la carpeta ./n8n-data con la carpeta interna de n8n.
   4. Docker abrió el puerto 5678 de tu compu.
   5. Todo está corriendo en segundo plano.

   Si todo salió bien, ves algo como [+] Running 2/2 - Container n8n Started.

   Verificar que n8n está corriendo:

   # Lista los contenedores activos
   docker ps
   
   # Deberías ver algo como:
   # CONTAINER ID   IMAGE        ...   PORTS                    NAMES
   # abc123def456   n8nio/n8n    ...   0.0.0.0:5678->5678/tcp   n8n
   

   Abre tu navegador y ve a http://localhost:5678. Deberías ver la pantalla de bienvenida de n8n. Si ves "This site can't be reached", espera 10 segundos y recarga —a veces tarda un poco en arrancar.

   Si algo sale mal:

   # Ver los logs de n8n para entender qué falló
   docker compose logs --tail 20
   
   # Detener y volver a empezar
   docker compose down
   docker compose up -d
   

4. Para detener y reiniciar n8n

   # Detener n8n (los datos se conservan)
   docker compose stop
   
   # Iniciar de nuevo
   docker compose start
   
   # Ver los logs en vivo
   docker compose logs -f
   
   # Detener y borrar el contenedor (datos se conservan en n8n-data/)
   docker compose down
   

5. Construir el workflow de enriquecimiento de leads

   Escenario: una consultora de servicios TI recibe leads desde un formulario de Google Forms. Quiere enriquecerlos con información de la empresa del lead y categorizarlos automáticamente.

   Paso 1 — Trigger: Manual (para pruebas). En el panel de n8n:

   1. Haz clic en "New Workflow".
   2. Nómbralo: Enriquecimiento de Leads.
   3. Agrega un nodo "Manual Trigger" (el que tiene una mano como icono).
   4. Define los datos de entrada que simularán un lead:

   [
     {
       "nombre": "Carlos Pérez",
       "email": "carlos@techcorp.com",
       "empresa": "TechCorp SAS",
       "cargo": "CTO",
       "pais": "Colombia",
       "empleados": 120,
       "industria": "Tecnología",
       "fecha": "2026-06-03"
     }
   ]
   

   Paso 2 — Enriquecer: Categorizar por tamaño de empresa

   Agrega un nodo "IF" (condicional) después del trigger:

   Condición: {{ $json.empleados > 500 }}
   → Sí: "Enterprise"
   → No: → Siguiente condición
   

   Agrega otro "IF" anidado para el rango medio:

   Condición: {{ $json.empleados >= 50 && $json.empleados <= 500 }}
   → Sí: "Medium"
   → No: "Small"
   

   Paso 3 — Crear el registro en un Google Sheet

   1. Agrega un nodo "Google Sheets".
   2. Conéctalo después de las condiciones.
   3. Configura:
      • Operación: "Append"
      • Sheet ID: el ID de tu Google Sheet (lo sacas de la URL: docs.google.com/spreadsheets/d/[ID]/edit).
      • Datos a escribir:

   Nombre: {{ $json.nombre }}
   Email: {{ $json.email }}
   Empresa: {{ $json.empresa }}
   Categoría: {{ $json.categoria }} (la variable que definiste en el IF)
   Fecha: {{ $json.fecha }}
   

   Para conectar n8n con Google Sheets necesitas autenticarte. n8n te guía con OAuth. El proceso es: autorizar, pegar el código, listo.

   Paso 4 — Enviar notificación a Slack

   1. Agrega un nodo "Slack" después de Google Sheets.
   2. Conecta tu espacio de trabajo de Slack.
   3. Configura:
      • Canal: #leads-entrantes
      • Mensaje:

   📩 Nuevo lead: {{ $json.nombre }} de {{ $json.empresa }}
   Categoría: {{ $json.categoria }} ({{ $json.empleados }} empleados)
   Email: {{ $json.email }}
   

   Paso 5 — Conectar los nodos

   La lógica ramificada de tu workflow:

   ⚡ Manual Trigger — entra el lead

   IF: empleados > 500

   ✅ Sí → Asignar "Enterprise" → Google Sheets → Slack

   No → IF: empleados entre 50 y 500

   ✅ Sí → Asignar "Medium" → Google Sheets → Slack

   ❌ No → Asignar "Small" → Google Sheets → Slack

   Las tres ramas convergen en el mismo destino: Google Sheets registra y Slack notifica. En el canvas de n8n se ve como un diagrama de flujo visual con esta misma lógica.

   Paso 6 — Ejecutar y probar

   1. Haz clic en "Execute Workflow" (el botón de play).
   2. Revisa los logs de cada nodo. n8n te muestra qué datos entraron y salieron de cada paso.
   3. Verifica que el Google Sheet tiene el nuevo registro.
   4. Verifica que el mensaje llegó a Slack.
6. Workflow completo: el código JSON

   Puedes importar este workflow directamente en n8n (Settings → Import). Es el mismo workflow descrito arriba pero en formato JSON (también viene en el kit: workflow-enriquecimiento-leads.json):

   {
     "name": "Enriquecimiento de Leads",
     "nodes": [
       {
         "parameters": {},
         "name": "Manual Trigger",
         "type": "n8n-nodes-base.manualTrigger",
         "position": [250, 300]
       },
       {
         "parameters": {
           "conditions": {
             "options": {
               "caseSensitive": true,
               "leftValue": "",
               "typeValidation": "strict"
             },
             "conditions": [
               {
                 "id": "e3e3c416-f652-4e93-b5f8-6c184a5b7a3a",
                 "leftValue": "={{ $json.empleados }}",
                 "rightValue": "500",
                 "operator": {
                   "type": "number",
                   "operation": "larger"
                 }
               }
             ]
           }
         },
         "name": "¿Es Enterprise?",
         "type": "n8n-nodes-base.if",
         "position": [450, 300]
       },
       {
         "parameters": {
           "conditions": {
             "options": {
               "caseSensitive": true,
               "typeValidation": "strict"
             },
             "conditions": [
               {
                 "id": "b7b7a416-f652-4e93-b5f8-6c184a5b7a3a",
                 "leftValue": "={{ $json.empleados }}",
                 "rightValue": "50",
                 "operator": {
                   "type": "number",
                   "operation": "largerEqual"
                 }
               },
               {
                 "id": "c7c7a416-f652-4e93-b5f8-6c184a5b7a3a",
                 "leftValue": "={{ $json.empleados }}",
                 "rightValue": "500",
                 "operator": {
                   "type": "number",
                   "operation": "smallerEqual"
                 }
               }
             ]
           }
         },
         "name": "¿Es Medium?",
         "type": "n8n-nodes-base.if",
         "position": [450, 500]
       },
       {
         "parameters": {
           "keepOnlySet": true,
           "values": [
             {
               "name": "categoria",
               "value": "Enterprise"
             }
           ]
         },
         "name": "Categoría: Enterprise",
         "type": "n8n-nodes-base.set",
         "position": [650, 200]
       },
       {
         "parameters": {
           "keepOnlySet": true,
           "values": [
             {
               "name": "categoria",
               "value": "Medium"
             }
           ]
         },
         "name": "Categoría: Medium",
         "type": "n8n-nodes-base.set",
         "position": [650, 400]
       },
       {
         "parameters": {
           "keepOnlySet": true,
           "values": [
             {
               "name": "categoria",
               "value": "Small"
             }
           ]
         },
         "name": "Categoría: Small",
         "type": "n8n-nodes-base.set",
         "position": [650, 600]
       },
       {
         "parameters": {
           "sheetId": "TU_SHEET_ID",
           "options": {},
           "operation": "append",
           "columns": {
             "mappingMode": "defineBelow",
             "value": [
               {
                 "key": "Nombre",
                 "value": "={{ $json.nombre }}"
               },
               {
                 "key": "Email",
                 "value": "={{ $json.email }}"
               },
               {
                 "key": "Empresa",
                 "value": "={{ $json.empresa }}"
               },
               {
                 "key": "Categoría",
                 "value": "={{ $json.categoria }}"
               },
               {
                 "key": "Fecha",
                 "value": "={{ $json.fecha }}"
               }
             ]
           }
         },
         "name": "Guardar en Google Sheets",
         "type": "n8n-nodes-base.googleSheets",
         "position": [850, 300]
       }
     ],
     "connections": {
       "Manual Trigger": {
         "main": [[{ "node": "¿Es Enterprise?", "type": "main", "index": 0 }]]
       },
       "¿Es Enterprise?": {
         "main": [
           [{ "node": "Categoría: Enterprise", "type": "main", "index": 0 }],
           [{ "node": "¿Es Medium?", "type": "main", "index": 0 }]
         ]
       },
       "¿Es Medium?": {
         "main": [
           [{ "node": "Categoría: Medium", "type": "main", "index": 0 }],
           [{ "node": "Categoría: Small", "type": "main", "index": 0 }]
         ]
       },
       "Categoría: Enterprise": {
         "main": [[{ "node": "Guardar en Google Sheets", "type": "main", "index": 0 }]]
       },
       "Categoría: Medium": {
         "main": [[{ "node": "Guardar en Google Sheets", "type": "main", "index": 0 }]]
       },
       "Categoría: Small": {
         "main": [[{ "node": "Guardar en Google Sheets", "type": "main", "index": 0 }]]
       }
     }
   }
   

   Para importarlo: Settings → Import → Pegar este JSON.

7. Migrar de trigger manual a trigger programado

   Para que el workflow se ejecute automáticamente cada hora (en lugar de manual):

   1. Reemplaza el nodo "Manual Trigger" por un nodo "Schedule Trigger" (reloj).
   2. Configura: intervalo "Minutes", cada 60.

   O si tienes un formulario real:

   1. Reemplaza por "Webhook Trigger".
   2. n8n genera una URL tipo https://localhost:5678/webhook/xyz.
   3. Configura tu formulario para que envíe los datos a esa URL.

4.1. Lo que Debe Estar Corriendo Siempre

# Verificar que n8n está activo
docker ps | findstr n8n    # Windows
docker ps | grep n8n       # macOS/Linux

# Ver logs
docker compose logs -f --tail 50

Si n8n no está corriendo, ningún workflow se ejecuta. Pon Docker Desktop para que arranque con tu sistema operativo.

4.2. Ideas de Workflows para tu Consultoría

4.3. Diagnóstico Rápido

• Autodiagnóstico: ¿n8n self-hosted es para ti?
• ¿Pagas por Zapier o Make hoy? → Multiplica tu gasto mensual × 12. Eso es lo que ahorrarías en un año con n8n self-hosted.
• ¿Pasas datos de una herramienta a otra manualmente? → Si son más de 2 horas a la semana, un workflow de n8n se paga solo en tiempo ahorrado.
• ¿Manejas datos sensibles de clientes que no deberían pasar por servidores de terceros? → n8n self-hosted mantiene todo en tu red.

4.4. Entregable del Módulo

Aprobación: 2 de 3 criterios en "Aprobado" o superior.

Para avanzar al Módulo 11: agrega un nodo HTTP Request que consulte una API externa (ej. Clearbit) para enriquecer el lead con datos públicos antes de categorizarlo. Así tu workflow no solo clasifica datos que ya tienes: busca datos que no tenías.

Kit: n8n Self-Hosted

📁 kits/m10-n8n/