Make avanzado: automatizar sin programar (hasta donde se pueda)
▶ Escuchar este artículo (18 min 7 s)
Resumir este artículo con:
ChatGPT
Claude
Grok
DeepSeek
Perplexity
¿Se puede automatizar algo complejo sin escribir una línea de código? La respuesta incómoda es: sí, hasta que ya no. Make es un buen laboratorio para explorar esa frontera. Es una plataforma visual en la que los flujos se construyen arrastrando piezas sobre un lienzo, y a medida que subes de nivel empieza a pedirte cosas que se parecen mucho a programar, aunque sin el editor de código.
Este artículo recorre lo que distingue un uso avanzado de uno básico: ramificaciones, bucles, errores, webhooks y escalado. También explica cuándo conviene usar otra herramienta.
De Integromat a Make, en tres frases
Make nació en Praga como Integromat. Las fechas tempranas dependen de la fuente: TechCrunch, citando a PitchBook, sitúa el lanzamiento en 2012, mientras que la Wikipedia checa habla de 2013 y de un renombrado a Integromat en octubre de 2015 (madegooddesigns.com). El 14 de octubre de 2020 la alemana Celonis adquirió la empresa; la prensa checa cifra la operación en más de 100 millones de dólares (Make, Czech the Valley). Make se lanzó como marca el 22 de febrero de 2022; el soporte de Integromat terminó el 30 de junio de 2023 y la plataforma se apagó el 30 de septiembre de 2023 (Make).
Hoy Make afirma conectar más de 3.000 aplicaciones nativas y servir a más de 500.000 organizaciones (Make, precios). Otros comparadores manejan cifras distintas (1.800, 3.500…). Son estimaciones de terceros que no coinciden entre sí, así que conviene quedarse con el dato oficial.
El vocabulario en 30 segundos
Imagina una cocina con comandas y platos:
- Escenario: la automatización completa, como el servicio entero de la cocina (documentación).
- Módulo: cada puesto, que hace una sola cosa (leer un correo, crear una fila, enviar un mensaje).
- Bundle («paquete»): lo que viaja entre puestos, el plato en marcha. Un módulo puede emitir un bundle o muchos (documentación).
- Trigger (disparador): el módulo que decide cuándo arranca todo. Puede ser programado (Make pregunta cada cierto tiempo si hay novedades) o instantáneo mediante webhook (el servicio avisa en el momento) (documentación).
- Operación o crédito: la unidad de facturación. Como regla general, cada ejecución de un módulo consume 1 crédito; las funciones avanzadas, como Code o IA, pueden consumir más (precios).
Lo que añade el nivel avanzado: routers, iteradores y agregadores
Routers: una cocina con varias salidas
Un router divide el flujo en varias rutas, cada una con su filtro o condición (documentación). Hay un detalle poco intuitivo: las rutas se procesan en secuencia, no en paralelo. Make no empieza la segunda hasta terminar la primera. Quien dibuja tres ramas esperando que corran a la vez se lleva una sorpresa.
También puedes definir una ruta de reserva (fallback) que recoja lo que no encaje en ninguna otra (documentación). Es el equivalente a la caja de «objetos perdidos»: nada se evapora sin que lo sepas.
Iteradores y agregadores: repartir y reagrupar
Piensa en una compra de supermercado que quieres repartir en varios pedidos, uno por tienda:
- El iterador convierte una lista (un array) en una serie de bundles, uno por elemento.
- El agregador de array hace lo contrario: junta muchos bundles en uno, por ejemplo para enviar un único mensaje con todo el resumen.
- El repeater repite una tarea un número fijo de veces.
La documentación de Make da un ejemplo clásico: recuperar correos con adjuntos y guardar cada adjunto como archivo suelto en Drive, iterando sobre Attachments[] (documentación).
Hablar con cualquier servicio: HTTP y funciones
El módulo HTTP, el conector universal
Cuando una aplicación no tiene integración nativa, el módulo HTTP permite llamar a cualquier API: admite los métodos GET, POST, PUT, PATCH, DELETE, HEAD y OPTIONS, con cabeceras, parámetros y cuerpo JSON (Make Apps). La versión HTTP v4 añade paginación nativa y un almacenamiento de claves más seguro (Make). Solo admite HTTPS y rechaza certificados no verificados.
Funciones: transformar datos sin programar
Make incorpora un lenguaje de funciones propio. Según la documentación, entre ellas hay:
- Generales:
if,ifempty,switch,get,set,pick,omit… (ayuda). - Matemáticas:
sum,average,round,median,formatNumber… (ayuda). - Texto:
split,replace(con expresiones regulares),upper,contains, además de hashes comosha256(ayuda). - Arrays:
map,merge,sort,slice,reverse… (ayuda).
Aquí ya se nota la frontera. Escribir replace(…; /regex/; …) en un campo no es programar en sentido estricto, pero tampoco es arrastrar y soltar.
Subescenarios: dividir para no perderse
Un escenario padre puede llamar a otros mediante Scenarios > Call a scenario. Sirve para simplificar flujos grandes y reutilizar lógica: construyes una pieza una vez y la invocas desde varios sitios. Puede ejecutarse en modo síncrono (el padre espera el resultado) o asíncrono (documentación).
Hay una limitación: solo se puede llamar a escenarios del mismo equipo. Para cruzar equipos u organizaciones hay que recurrir a Make > Run a scenario o a un custom webhook (documentación).
Manejo de errores: la prueba de fuego
Aquí es donde un escenario deja de ser un juguete. Un gestor de errores es una ruta que se conecta a un módulo: si ese módulo falla, en vez de detener todo, Make sigue una lógica que tú has definido (documentación).
Imagina un peaje con carriles de reserva. Hay cinco directivas, con los nombres actuales de la interfaz. Los antiguos, que aún aparecen en documentación y cursos antiguos, van entre paréntesis (Academy, Make):
- Skip (antes Ignore): descarta el bundle que falla y continúa. El escenario termina en éxito. Va bien cuando el dato malo es ocasional e intrascendente.
- Retry (antes Break): retira el bundle fallido, lo guarda como ejecución incompleta y deja seguir al resto. El escenario acaba con un aviso. Admite reintentos automáticos configurables en número e intervalo. La Academy cita el caso de un rate limit de una API que se puede reintentar a los 60 segundos en lugar de esperar 20 minutos.
- Resume: sustituye la salida del módulo fallido por un valor de reserva y el escenario sigue como si nada. Por ejemplo, rellenar con un valor por defecto un teléfono que faltaba.
- Commit: detiene el escenario y confirma los cambios ya hechos en módulos con transacciones.
- Rollback: detiene el escenario y revierte esos cambios. Es el comportamiento por defecto si no configuras nada y las ejecuciones incompletas están desactivadas (documentación).
Tres detalles prácticos:
- Activar Store incomplete executions permite reanudar tras corregir el problema sin perder datos, y es requisito para usar Retry.
- Por defecto, tres errores consecutivos desactivan el escenario.
- Los módulos de gestión de errores no consumen créditos (precios).
Una regla práctica muy repetida en la comunidad, y que es opinión, no documentación oficial: usar Retry para reintentar con control, Resume para aportar un valor de reserva y Skip para errores no críticos, y evitar Commit y Rollback por sus efectos secundarios (Medium).
Webhooks: que el flujo reaccione al instante
Un webhook crea una URL a la que otros sistemas envían datos. Cuando llega una petición, el escenario arranca de inmediato, en lugar de esperar al siguiente sondeo. Existen webhooks específicos de aplicación y custom webhooks de URL libre. El módulo Webhook response permite además contestar al sistema que llama, con estado, cabeceras y cuerpo (documentación).
Los límites que conviene conocer:
- Paralelismo: por defecto, los escenarios con webhooks instantáneos se ejecutan en paralelo. Si necesitas orden estricto, se activa Process data in order (documentación).
- Ritmo: puedes fijar un máximo de ejecuciones por minuto (100 por defecto) para no saturar APIs externas; las peticiones sobrantes se encolan (documentación).
- Cola: depende del plan. Según la página de precios, 667 por defecto con 10.000 créditos y hasta 10.000 como máximo. Si se llena, Make responde con HTTP 400 «Queue is full» (precios, Vatech).
- Tamaño: un blog de terceros menciona un máximo de 5 MB por petición (Vatech); ese dato conviene confirmarlo en la documentación oficial.
Cuando la cosa crece: ingeniería disfrazada de lienzo
Con volúmenes altos, el lienzo empieza a pedir los mismos hábitos que el código tradicional:
- Descomponer por responsabilidad. Un patrón recomendado por un blog especializado es separar entrada (recibe el webhook, valida, guarda y responde rápido), procesamiento, distribución y gestión de errores en escenarios distintos, de modo que un fallo no bloquee a los demás (Vatech).
- Poner una cola en medio, con data stores u otro almacenamiento intermedio y estados como «pending/processing/done/failed». Los data stores son pequeñas bases de datos internas para guardar información entre ejecuciones (SDK).
- Respetar las APIs externas: agrupar en lotes, paginar con cursores y reintentar con espera creciente ante errores 429 o 5xx, acotando los intentos.
- Vigilar la capacidad en paralelo. Make mide en Processing Units cuántas ejecuciones simultáneas soporta la organización. Al superar el límite, los instantáneos con respuesta reciben un 429 «Too many executions running in parallel», los instantáneos sin respuesta se encolan y los programados se retrasan (documentación).
- Monitorizar: la API expone los registros de ejecución (
GET /scenarios/{id}/logs) con filtros por estado, duración y operaciones (Vatech).
La frontera: cuando «sin programar» roza el programar
La documentación sobre capacidad paralela recomienda sustituir, para transformaciones complejas, una larga cadena de iterar y agregar por el Code app, que suele ser más rápido y gastar menos recursos y créditos (documentación).
El Code app permite escribir y ejecutar JavaScript o Python dentro del escenario, en un entorno aislado y con librerías habituales como lodash, pandas o numpy (Make, Make Apps). Hay matices:
- Coste: según un blog de Zapier (competidor de Make, así que toma el dato con cautela), consume 2 créditos por segundo de ejecución (Zapier).
- Seguridad: la propia documentación aconseja usar el módulo HTTP para llamar a APIs, porque protege las credenciales. Con el Code app, ocultar datos sensibles en los registros queda a criterio del usuario (Make Apps).
- Funciones personalizadas: son funciones JavaScript creadas por el usuario, disponibles de forma nativa en planes Enterprise (SDK).
- Automatizar la propia plataforma: Make ofrece API, SDK en TypeScript y CLI para gestionar escenarios, equipos y data stores por código (SDK).
Mi lectura, que es análisis y no un dato: la frontera entre «sin código» y «con código» se difumina según subes de nivel. Make empuja hacia código dentro del propio Make o hacia patrones de ingeniería (colas, descomposición, monitorización). No es una crítica, es la naturaleza del problema: lo complejo es complejo, lo dibujes o lo escribas.
IA dentro de Make
Make incluye varias capas de IA. Esto es lo que dice la empresa:
- Make AI Agents: agentes que razonan, deciden y lanzan automatizaciones reales, con un panel de razonamiento que muestra qué herramientas llaman y por qué (Make, anuncio).
- Maia: un compañero de IA en el constructor que crea y corrige escenarios por conversación en lenguaje natural (Make).
- Make Grid: un mapa visual de escenarios, apps, agentes y dependencias de una organización (Make).
Parte de esto procede de la documentación de novedades de 2026, junto con If-else y Merge, la Make Functions app y las suscripciones a eventos firmados (ayuda). Conviene confirmar su vigencia antes de basar un proyecto en ellas. Las líneas que Make anuncia a futuro (agentes más autónomos, Maia «omnipresente», monitorización proactiva, soporte multiherramienta en Grid) son anuncios de hoja de ruta, no hechos consolidados.
Cuánto cuesta (orientativo)
Se factura por créditos. Casi cada módulo ejecutado cuenta como 1; los routers y los módulos de error no consumen (precios). Según un análisis de terceros de 2026, el plan gratuito da 1.000 créditos al mes con un intervalo mínimo de 15 minutos; Core ronda los 12 $/mes en facturación anual con 10.000 créditos; Pro unos 21 $ y Teams unos 38 $; Enterprise es a medida (Zapier). Otros comparadores dan cifras distintas (Core, por ejemplo, entre 9 y 12 $) (Activepieces). Trata estos precios como orientativos y confirma en la página oficial.
¿Make, Zapier, n8n o código propio?
Buena parte de las comparativas disponibles procede de terceros o de competidores, así que esta tabla resume perfiles, no veredictos:
¿Make, Zapier, n8n o código propio?
Cuatro vías · Perfiles, no veredictos · Comparativas de terceros consultadas a 8 de noviembre de 2026
Si no ves todas las columnas, puedes deslizar la tabla hacia los lados.
| Opción | Encaja cuando… | Puntos a tener en cuenta |
|---|---|---|
| Makelienzo visual | El equipo automatiza y nadie programa; hay ramas, bucles y transformaciones | Facturación por módulo; la complejidad exige disciplina |
| Zapierconfigurar rápido | Quieres configurar rápido y necesitas un catálogo muy amplio | Facturación por «trabajo completado»; menos control fino de ramificación |
| n8nautoalojado | Hay un ingeniero a cargo y quieres autoalojar y meter código propio | Licencia de uso sostenible, no código abierto puro |
| Código propioa medida | Volumen alto, tiempo real o coste a gran escala | Más mantenimiento; más responsabilidad |
1 Perfiles resumidos a partir de las comparativas de terceros citadas abajo. Ninguna de las empresas mencionadas patrocina este contenido.
2 El ahorro del 50–70 % de Make frente a Zapier lo publica un blog de terceros: trátalo como orientativo y confirma precios y límites en las páginas oficiales.
Comparativas de terceros consultadas: Make · Zapier · Parseur · WorkflowDone.
La mirada de LedSolEo
Perfiles, no veredictos
Las comparativas sobre estas cuatro vías las publican casi siempre terceros o competidores, así que conviene leerlas como retratos de para quién funciona cada herramienta y no como un podio.
De todas ellas, la conclusión que nos parece más útil es esta: los tres enfoques son capas, no rivales, y lo sensato es usar la herramienta más simple que resuelva bien el problema.
Un blog de terceros habla de un ahorro típico del 50–70 % de Make frente a Zapier en comparaciones equivalentes. Es una estimación de terceros, no un dato contrastado. Lo más sensato de esa misma fuente es su conclusión: los tres enfoques son capas, no rivales, y conviene usar la herramienta más simple que resuelva bien el problema (WorkflowDone). Y si el problema no es automatizar tareas sino crear una aplicación entera, hoy hay un atajo que no aparece en esas comparativas: crear la aplicación hablando con una IA.
Cierre: pensar en cajas, flechas y errores
Automatizar sin programar no es automatizar sin pensar. Un escenario avanzado exige decidir qué pasa cuando algo falla, cómo se reparten los datos y qué ocurre si de golpe llegan mil peticiones en lugar de diez. Make pone el lienzo, pero el criterio sigue siendo tuyo. La buena noticia es que, para muchísimos casos, ese criterio cabe en cajas y flechas. Y cuando no cabe, el propio Make te deja una puerta al código.
Para ampliar información
Documentación oficial de Make
- Routers: help.make.com/router
- Control de flujo (iteradores, agregadores, repeater): help.make.com/flow-control
- Gestión de errores: help.make.com/Overview-of-error-handling
- Webhooks: help.make.com/webhooks
- Funciones: https://help.make.com/general-functions · https://help.make.com/math-functions · https://help.make.com/text-and-binary-functions · https://help.make.com/array-functions
- Subescenarios: help.make.com/subscenarios
- Capacidad en paralelo y programación: https://help.make.com/parallel-capacity · https://help.make.com/schedule-a-scenario
- Apps HTTP y Code: https://apps.make.com/http · https://apps.make.com/code
- Webhooks en apps personalizadas: developers.make.com/custom-apps-documentation/app-components/webhooks
- Novedades 2026: help.make.com/2026
- Precios y comparativa oficial: https://www.make.com/pricing · https://make.com/en/compare/make-vs-zapier
- SDK: jsr.io/@make/sdk/doc/all_symbols
- Curso de gestión de errores (Academy): academy-content.make.com/courses/make-intermediate-errors/04-error-handlers
Historia y producto
- https://www.make.com/en/integromat-evolves-to-make
- https://www.make.com/end-of-integromat
- https://www.make.com/blog/integromat-2020-in-review
- https://www.make.com/blog/make-code-app
- https://www.make.com/blog/make-http-app-upgrade
- https://www.make.com/blog/waves-make-product-releases-2025
- https://www.make.com/blog/make-maia-no-code
- https://www.make.com/blog/announcing-next-generation-make-ai-agents
- https://www.make.com/ai-agents
- https://make.com/en/blog/workflow-automation-error-what-to-do
Terceros (análisis y estimaciones)
- https://madegooddesigns.com/make-com-brand-guidelines
- https://www.czechthevalley.com/l/there-are-great-things-ahead-of-us-say-co-founders-of-integromat-czech-startup-acquired-by-celonis-for-over-100-million/
- https://zapier.com/blog/make-com-pricing/ · https://zapier.com/compare/zapier-vs-make
- https://www.activepieces.com/blog/makecom-operations-pricing-calculator-2026-guide
- https://www.vatech.io/blog/scaling-make-com-enterprise-high-volume-automation/
- https://workflowdone.com/when-to-use-zapier-vs-make-com-vs-custom-code
- https://parseur.com/es/blog/zapier-n8n-make
- https://medium.com/@supbarty/best-practises-for-error-handling-in-make-com-explained-b73e1cfbf86d
