Módulo 1: Triggers Avanzados

Mini-Proyecto: Comparativa Práctica de los 4 Triggers Principales

Siguiente →

Descripción de la cápsula

Cierre del módulo. Para consolidar todo lo aprendido, vas a construir un workflow comparativo que acepta los 4 tipos principales de trigger en paralelo y los registra en un Sheet. Es un proyecto pequeño pero pedagógicamente valioso: vas a ver con tus propios ojos la diferencia de latencia, frecuencia, y comportamiento de cada trigger.

No es un workflow productivo (no resuelve un problema real). Es un laboratorio práctico para internalizar los conceptos. Después de construirlo, vas a tener intuición sólida sobre cuándo cada trigger brilla — útil para el resto de tus proyectos.

Lo que vas a aprender

Al terminar este mini-proyecto serás capaz de:

  • ✅ Comparar empíricamente los 4 tipos de trigger
  • ✅ Verificar latencias y frecuencias en la práctica
  • ✅ Consolidar el conocimiento conceptual del módulo
  • ✅ Reconocer el comportamiento de cada uno en contexto real

El workflow

Estructura

[Manual Trigger]    ─→ [Set: type="manual",   timestamp={{ $now }}]    ──┐
[Schedule cada 5m]  ─→ [Set: type="schedule", timestamp={{ $now }}]    ──┤
[Webhook]           ─→ [Set: type="webhook",  timestamp={{ $now }}]    ──┼─→ [Sheet: append log]
[Gmail Trigger]     ─→ [Set: type="gmail",    timestamp={{ $now }}]    ──┘

Cuando cualquier trigger dispara, agrega una fila al Sheet con:

  • type: cuál trigger fue
  • timestamp: cuándo se ejecutó
  • (Opcional) datos relevantes del payload

Por qué este diseño

  • Mismo procesamiento después del Set (cápsula 07 — caso de uso 1)
  • Log centralizado permite ver patrones de cuándo dispara cada uno
  • Comparativa empírica de latencias

Paso 1: Preparar el Sheet

Crea (o reusa) un Sheet llamado Trigger Lab. Hoja log con columnas:

  • type
  • timestamp
  • notes

3 columnas alcanza.

Paso 2: Crear el workflow

2.1. Workflow nuevo

Nombre: [G2-M01] Comparativa de triggers

2.2. Agregar los 4 triggers

Trigger 1: Manual

  • Solo agrega Manual Trigger

Trigger 2: Schedule cada 5 min

  • Schedule Trigger
  • Mode: Cron Expression
  • Expression: */5 * * * * (cada 5 min)
  • Timezone: la tuya

Trigger 3: Webhook

  • Webhook Trigger
  • HTTP Method: POST
  • Path: dejar generado
  • (Sin auth para mantenerlo simple — pero no lo dejes activo en producción real)

Trigger 4: Gmail Trigger

  • Gmail Trigger
  • Credential: tu Google
  • Event: Message Received
  • Polling Interval: 1 min (si tu plan lo permite)
  • Filter: subject:test-trigger-lab (para que solo procese emails específicos, no todos los que llegan)

2.3. Agregar Set después de cada trigger

Después de cada trigger, agregar un Set:

Set después de Manual:

  • Field 1: type = String, "manual"
  • Field 2: timestamp = String, {{ $now }}
  • Field 3: notes = String, "Disparado manualmente"

Set después de Schedule:

  • type = "schedule"
  • timestamp = {{ $now }}
  • notes = "Schedule cada 5 min"

Set después de Webhook:

  • type = "webhook"
  • timestamp = {{ $now }}
  • notes = {{ "Webhook payload: " + JSON.stringify($json.body) }}

Set después de Gmail:

  • type = "gmail"
  • timestamp = {{ $now }}
  • notes = {{ "Email from: " + ($json.from?.value?.[0]?.address || 'unknown') }}

(Los paths exactos para Gmail dependen de la versión — ajusta según output real.)

2.4. Agregar Sheet append (común a todos)

Conectar los 4 Sets a el mismo nodo Sheets:

  • Google Sheets node
  • Operation: Append Row
  • Document: Trigger Lab
  • Sheet: log
  • Columns:
    • type = {{ $json.type }}
    • timestamp = {{ $json.timestamp }}
    • notes = {{ $json.notes }}

Paso 3: Activar y observar

3.1. Activate el workflow

Toggle Active = ON.

3.2. Esperar y observar

Durante las próximas 2-3 horas, deja correr y observa el Sheet.

Lo que vas a ver:

  • Schedule: filas nuevas cada 5 min (automáticas, sin intervención)
  • Manual: filas solo cuando tú lo dispares desde el editor
  • Webhook: filas cuando mandes un POST desde curl/Postman
  • Gmail: filas cuando llegue un email matching el filtro

3.3. Acciones para disparar manualmente

Durante el experimento, dispara cada uno varias veces:

Manual: abre editor → Execute Workflow (×3)

Webhook: desde curl o Postman:

curl -X POST 'https://your-account.app.n8n.cloud/webhook/abc123' \
  -H 'Content-Type: application/json' \
  -d '{"test": "value 1"}'

Repite 2-3 veces con valores distintos.

Gmail: mándate un email a ti mismo con subject que contenga test-trigger-lab. Ej:

Subject: test-trigger-lab #1
Body: cualquier cosa

Paso 4: Análisis

Después de 2-3 horas, abre el Sheet y observa.

Análisis sugerido

Conteo por tipo

¿Cuántas filas hay de cada tipo?

TipoEsperadoReal
schedule~24-36 (cada 5 min × 2-3 hrs)?
manualtantas como hayas hecho click?
webhooktantas como hayas mandado?
gmailtantos emails que mandaste?

¿Coinciden? Si no, hay algo que investigar (cápsula 6 de G1 — debug).

Latencias

Para Webhook y Gmail, compara la marca de tiempo del evento original (mensaje enviado, request emitido) con la timestamp registrada en el Sheet.

  • Webhook: debería ser <2 segundos
  • Gmail: depende del polling interval (1-5 min)

Esto te da una sensación visceral de la diferencia entre push y polling.

Distribución horaria

Filtra por hora. ¿En qué horas hubo más actividad?

  • Schedule: distribuido uniformemente
  • Manual/Webhook: picos según cuándo testeaste
  • Gmail: picos cuando llegaron emails

Paso 5: Experimentos adicionales

Si quieres profundizar, prueba:

Experimento A: Mata un trigger, observa

  1. Desactiva temporalmente uno de los Set después de un trigger (Disable)
  2. Espera 30 min
  3. Verifica que ese trigger sigue ejecutando pero la fila ya no se crea
  4. Re-activa

Aprendizaje: triggers son independientes — desactivar un Set después no detiene el trigger en sí.

Experimento B: Cambia polling de Gmail

  1. Cambia polling interval de Gmail de 1 min a 15 min
  2. Manda email
  3. Espera y observa cuándo aparece la fila

Aprendizaje: polling interval literalmente define latencia.

Experimento C: Bombarea con webhooks

  1. Manda 20 webhooks en 1 segundo con un script
  2. Observa Executions — ¿n8n los procesa en serie o paralelo?
  3. Cuenta cuántas filas terminan en Sheet

Aprendizaje: concurrency del workflow puede mostrar diferencias.

Limpieza

Cuando termines el experimento:

  1. Desactiva el workflow (toggle Active = OFF) — no quieres que siga corriendo cada 5 min para siempre
  2. Considera eliminar el workflow si no piensas reutilizarlo

Reflexión final

Preguntas para pensarte

  1. De los 4 triggers, ¿cuál te sorprendió más en su comportamiento?
  2. ¿Cuándo elegirías polling sobre push después de este experimento?
  3. Si tuvieras que diseñar un workflow para "responder a registros nuevos", ¿qué trigger usarías y por qué?
  4. ¿Qué latencia te parece aceptable para distintos casos de negocio?

Anota tus respuestas — son la base para diseñar workflows reales en el resto del path.

Lo que aprendiste en este módulo (zoom out)

Antes de M01Después de M01
Conocías Manual, Schedule, Webhook básicosCatálogo completo de triggers + categorización
Schedule "cada hora" simpleCron expressions de negocio + timezone management
Webhook básico sin authWebhook seguros con auth, response modes, HMAC
No usabas app-event triggersGmail/Slack/Calendar triggers configurados
"Mi workflow no responde rápido" — frustraciónDecisiones conscientes polling vs push
Un trigger por workflowCombinaciones de triggers cuando aplica

Más importante: ahora eliges trigger conscientemente según trade-offs, no por inercia.

Resumen y siguiente paso

  • Mini-proyecto comparativo de los 4 triggers principales
  • Vas a observar empíricamente: latencias, frecuencias, comportamientos
  • Construcción simple: cada trigger → Set marca su tipo → Sheet log común
  • 3 experimentos adicionales opcionales para profundizar
  • Después de hacerlo, tendrás intuición sólida sobre cuándo cada trigger brilla

Antes de pasar a M02 deberías tener:

  • El workflow comparativo construido y observado por al menos 1 hora
  • Sheet con datos de los 4 triggers
  • Respuestas mentales a las preguntas de reflexión

Lo que sigue (Módulo 2 — Branching y Decisiones Avanzadas):

M02 profundiza el branching que viste en G1-M07. Vas a aprender:

  • Patrones AND/OR complejos anidados
  • Switch con 4+ ramas y subroutines
  • Decisiones con datos calculados (precomputar antes de IF)
  • Anti-patterns del "if hell"
  • Sub-workflows para manejar complejidad

Sin profundizar branching, los workflows complejos se vuelven inmantenibles. M02 te da las herramientas.

Recursos adicionales

  1. n8n Trigger Comparison Guide - Referencia completa.
  2. Latency Patterns in Distributed Systems - Latencias típicas en sistemas distribuidos (avanzado pero útil para perspectiva).

Creado: Mayo 11, 2026 Versión: 1.0

← AnteriorCombinar Múltiples Triggers en un WorkflowSiguiente →Introducción al Módulo: Branching y Decisiones Avanzadas