
Si has oído hablar de Make pero no sabes por dónde se empieza, esto son seis minutos que te ahorran una tarde de tutoriales sueltos.
Te cuento cómo está hecho un escenario por dentro, los tres tipos de módulo que existen, cuándo se ejecuta cada cosa, y sobre todo lo que de verdad cuesta dinero: las operaciones. Termino con la diferencia entre un escenario de juguete y uno que aguanta funcionando solo.
Sin humo y sin relleno. Son los conceptos que necesitas antes de tocar la herramienta.
CAPÍTULOS
00:00 Entrada
00:34 Qué es Make
01:03 Anatomía de un escenario
01:14 Un escenario es una cadena de módulos
01:43 Los tres tipos de módulo
02:06 Cuándo se ejecuta
02:31 Lo que de verdad cuesta dinero
02:58 El filtro va antes, no después
03:27 Cuando el flujo se bifurca
03:38 Las dos piezas que rompen la línea recta
03:59 De juguete a producción
04:10 Las tres diferencias que se notan
04:45 Tu primer escenario, hoy
05:13 Cierre
Este vídeo es la introducción de la serie: los conceptos, antes de tocar nada. Después vienen seis partes prácticas, grabadas dentro de Make, montando escenarios que funcionan y ejecutándolos en directo.
Abro Make y te enseño lo que ves cuando creas un escenario nuevo. Un minuto y veinte, sin rodeos.
El lienzo en blanco, el catálogo de aplicaciones, cómo se busca lo que necesitas, y dónde se decide cada cuánto se ejecuta todo. Que es justo la opción que más gente se salta y más cara sale.
CAPÍTULOS
00:00 El lienzo en blanco
00:21 El primer módulo
00:37 Buscar la aplicación
00:53 Cada cuánto se ejecuta
01:09 Cierre
Parte 1 de 6 de la serie práctica. Los conceptos están en el vídeo de introducción; a partir de aquí es todo Make de verdad, grabado en directo.
El ciclo completo de un módulo, de principio a fin: elegirlo, configurarlo, guardarlo, ejecutarlo y comprobar lo que devuelve.
Y al final aparece el número que importa. Una operación por módulo ejecutado, con la entrada y la salida delante. Lo que en la parte 1 era una afirmación, aquí se ve con la cifra en pantalla.
CAPÍTULOS
00:00 Retomamos donde lo dejamos
00:26 Elegir el módulo
00:43 Configurarlo
00:59 Guardar
01:15 Ejecutarlo
01:33 Lo que devuelve
01:53 Cierre
Parte 2 de 6 de la serie práctica.
Monto un flujo entero de dos módulos que llama a una API real y usa lo que devuelve. Con una API pública, sin clave y sin registro, para que puedas repetirlo tal cual mientras lo ves.
Dentro está el módulo comodín de Make, las cuatro formas en que se protege una API, la opción de analizar la respuesta que decide si puedes coger campos sueltos, y el mapeo, que es la habilidad que de verdad hay que aprender de esta herramienta.
Termina viendo el tipo de cambio real viajando de un módulo al siguiente.
CAPÍTULOS
00:00 Lo que vamos a montar
00:26 El módulo comodín
00:42 La autenticación
01:05 La dirección
01:20 Analizar la respuesta
01:48 Probarlo antes de seguir
02:12 Encadenar el segundo
02:34 El mapeo
03:06 Ejecutar el flujo entero
03:24 El dato, al final del camino
03:41 Cierre
La API que uso: https://api.frankfurter.dev
Parte 3 de 6 de la serie práctica.
Rompo un escenario a propósito para enseñarte lo que casi ningún tutorial enseña: qué se ve cuando algo falla, dónde está la información útil, y cómo se maneja.
El error es real, no simulado. Le pido a la API una moneda que no existe y el servidor contesta lo que contesta. Después añadimos el manejador de errores y volvemos a ejecutar sin arreglar nada, para ver la diferencia.
Con el matiz que separa esto de un tutorial: ignorar todos los errores es la opción rápida, no la buena.
CAPÍTULOS
00:00 Lo que vamos a romper
00:27 El mismo módulo
00:42 La trampa
01:05 Romperlo
01:25 Leer el error
01:49 El manejador
02:01 La rama nueva
02:18 Ejecutar otra vez
02:36 Lo que no ha cambiado
03:02 Cierre
Parte 4 de 6 de la serie práctica.
El filtro es la pieza que más operaciones ahorra de todo Make, y casi nadie la pone hasta que ya es tarde. Aquí se ve funcionando, con el contraste delante.
Ejecuto el mismo flujo dos veces. Primero sin filtro, y los dos módulos gastan. Luego pongo el filtro y vuelvo a ejecutar: el segundo módulo ni se entera. Una operación menos, cada vuelta y todo el mes.
Con la regla que de verdad importa: el filtro va lo antes posible, porque lo que ya se ha ejecutado ya lo has pagado.
CAPÍTULOS
00:00 Volvemos a montar el flujo
00:30 Configurar la llamada
01:03 El segundo módulo
01:30 Sin filtro: se gasta todo
01:54 La llave de la conexión
02:05 La condición
02:37 Con filtro: se para
03:00 Lo que acabas de ahorrar
03:26 Cierre
Parte 5 de 6 de la serie práctica.
Hasta ahora el escenario preguntaba cada cierto tiempo si había algo nuevo. Con un webhook es al revés: la otra aplicación te avisa a ti, y el escenario salta en el momento.
Y no te lo cuento, te lo enseño. Creo el webhook y le mando datos de verdad desde fuera del navegador, desde otro programa de mi ordenador, que es exactamente lo que haría una aplicación avisándote. Se ve llegar la petición y se ve a Make aprender la estructura solo.
La dirección del webhook va difuminada a propósito, y eso también es parte de la clase: esa dirección es la llave de tu escenario y se trata como una contraseña.
CAPÍTULOS
00:00 Preguntar o que te avisen
00:32 El disparador instantáneo
00:49 Crear la puerta
01:06 Por qué la tapo
01:24 Escuchando
01:45 Aprende la estructura
02:05 Ahora de verdad
02:28 Cuándo usar cada uno
02:48 Cierre
Parte 6 de 6 de la serie práctica.
Montar escenarios está bien, pero lo que vas a hacer casi siempre es heredar uno y tener que entender qué hace antes de atreverte a tocarlo. Así que aquí cambiamos el ejercicio: leemos uno ya hecho.
Es un caso de comercio y resuelve una pregunta de cualquiera que venda algo: de todo el catálogo, qué me interesa mirar hoy. Cuatro piezas, ninguna rara. Abrimos la llamada, abrimos el iterador, miramos dónde vive el filtro (que no es una pieza, va sobre la línea), y lo ejecutamos para leer el número que pinta encima: seis de diez han pasado.
Y al final, lo importante: el mismo flujo vale para un almacén que avisa de stock bajo, una inmobiliaria que saca los pisos parados o una clínica que lista las citas de mañana.
CAPÍTULOS
00:00 Leer en vez de construir
00:26 La llamada
00:52 El iterador
01:16 El filtro
01:42 Juntar y guardar
02:10 Ejecutarlo
02:41 Llevarlo a lo tuyo
Parte 7 de 8 de la serie práctica.
Este es el error más común de todos con Make, y se ve con un número que no cuadra.
Entran ocho contactos. Por la ruta de ingeniería pasan dos, por la de marketing pasa uno, y por la tercera, que no lleva filtro, pasan ocho. Dos más uno más ocho son once, y solo habían entrado ocho. Ese número imposible es toda la clase: el router NO reparte, manda cada paquete por todas las rutas y es el filtro de cada una el que decide.
Te enseño por qué pasa, cómo se arregla (filtro contrario o ruta de reserva) y lo que te está costando en operaciones mientras no lo arregles.
CAPÍTULOS
00:00 Cuando no todo va al mismo sitio
00:27 Hasta ahí, lo de siempre
00:45 Tres caminos
01:05 El filtro de cada ruta
01:23 Ejecutarlo
01:51 Dos, uno... y ocho
02:12 Por qué pasa y cómo se arregla
02:39 Lo que te está costando
03:00 A lo tuyo
Parte 8 de 8 de la serie práctica.
Ya sabes montar escenarios y sabes leerlos. Queda la pregunta que de verdad decide si esto te sirve: qué automatizas primero. Y esa no se contesta dentro de Make, se contesta mirando tu negocio.
Recorremos lo que monta el primer día una tienda, un despacho o gestoría, una inmobiliaria y una clínica. Cuatro casos que por debajo son el mismo flujo con otra fuente y otra condición.
Y la parte que más se agradece: por qué casi todo el mundo elige mal el primer escenario, y cómo elegir el tuyo esta semana con un papel y dos días de apuntes.
CAPÍTULOS
00:00 Entrada
00:23 Lo que hay debajo de todo
00:34 Las cuatro formas
01:04 Comercio
01:14 Lo primero de una tienda: el stock
01:42 Despachos y gestorías
01:51 Clasificar lo que entra
02:18 Inmobiliaria
02:28 Lo primero: la velocidad
02:54 Clínicas y servicios con cita
03:05 El recordatorio de cita
03:29 El primer escenario: mal y bien
04:05 Lo que se repite en los cuatro
04:35 Cómo elegir el tuyo esta semana
05:02 Lo que te llevas
05:20 Cierre
Clase final de la serie. Después de esta ya no necesitas otro tutorial: necesitas un caso tuyo y una tarde.
Hay dos formas de aprender Make. Una es ver a alguien montar un escenario que ya le funcionaba antes de empezar a grabar. La otra es esta.
En este curso monto los escenarios delante de ti, contra la herramienta de verdad, y los ejecuto. Cuando algo falla, falla en pantalla y lo arreglamos ahí mismo. No hay resultados preparados ni pantallas de mentira.
QUÉ VAS A MONTAR
Empezamos por los conceptos, en un módulo corto que te ahorra una tarde de tutoriales sueltos: cómo está hecho un escenario por dentro, los tres tipos de módulo, cuándo se ejecuta cada cosa, y lo que de verdad cuesta dinero.
A partir de ahí, todo es práctica. Abrimos Make, montamos un flujo que llama a una API pública real, mapeamos el dato de un módulo al siguiente, y lo ejecutamos hasta ver el resultado en pantalla. Después lo rompemos a propósito para aprender a leer un error, le ponemos un filtro para dejar de gastar operaciones de más, y terminamos con un webhook recibiendo datos enviados desde fuera en directo.
LO QUE ESTE CURSO HACE DISTINTO
La mayoría de cursos de automatización enseñan a construir. Este además enseña a que aguante.
Vas a ver un escenario fallar, con el error real del servidor delante, y vas a aprender dónde está la información útil dentro de ese error. Vas a entender por qué el filtro va lo antes posible, con el contador de operaciones delante para que veas la diferencia. Y te voy a decir cuándo la opción rápida no es la buena, que es la clase de matiz que normalmente solo se aprende pagándolo.
TODO SE PUEDE REPETIR
Uso una API pública, sin clave y sin registro, para que puedas hacer exactamente lo mismo que ves mientras lo ves. Y ninguna parte del curso necesita conectar una cuenta de Google, de Slack ni de nada: todo funciona con el plan gratuito de Make y con herramientas internas.
PARA QUIÉN NO ES
Si buscas una lista de plantillas para copiar y pegar, este no es tu curso. Aquí se explica el mecanismo, para que sepas montar lo que necesites en vez de buscar quién lo montó antes.
Soy Joan Medina, desarrollador senior y consultor de automatización e inteligencia artificial. Llevo años montando estas cosas para clientes, y este curso es lo que me habría gustado encontrar cuando empecé.