Si estás armando escenarios en Make y te pasa esto…

• “Ya lo setee… ¿por qué el Get devuelve vacío?”

• “En una ruta funciona y en otra no”

• “Se recalcula 10 veces lo mismo”

• “Cuando entra por webhook con muchos bundles, el estado se pierde”

…el problema casi siempre es el mismo: no estás usando bien las variables del escenario.

En Make, las Scenario Variables te permiten guardar un valor con un nombre (Set variable) y recuperarlo después (Get variable) dentro de una ejecución. Son la forma más simple de controlar flujo, evitar trabajo duplicado y guardar resultados intermedios.

Qué son las variables en Make (explicado simple)

Las variables son simplemente contenedores para guardar datos.

Pensalo así:

• Set variable = “guardá esto con este nombre”
• Get variable = “traeme lo que guardé con este nombre”

Al usar Make probablemente necesites guardar ciertos datos para obtenerlos mas adelante en el flujo. Un usuario, un email, el stock disponible en tu tienda de e-commerce, estos son solo algunos ejemplos.

Para qué sirven (más allá de un flag)

1) Guardar cálculos intermedios

Ejemplos:

• un status calculado
• una fecha formateada
• una Cantidad de Stock calculada
• un JSON armado para mandarlo a otra ruta

2) Reutilizar resultados (ahorrar operaciones)

Si una ruta necesita el mismo dato (ej: un “lookup” o una transformación), lo guardás una vez y lo reusás.

3) Armar un “estado” entre módulos

Ej: “ya procesé X”, “me falta Y”, “este item ya lo actualicé”.

Set vs Get Variable

Set Variable

Cuando agregás Tools → Set variable definís:

• Variable name (obligatorio)
• Variable lifetime (One cycle / One execution)
• Variable value (texto, número, boolean, JSON, etc.)

One cycle: vive solo durante un ciclo (se “resetea” si la ejecución tiene más de un ciclo).

One execution: vive durante toda la ejecución (puede incluir múltiples ciclos). La opción por Default.

Get Variable

Tools → Get variable busca por nombre y te devuelve el valor para mapearlo en:

• filtros
• condiciones
• módulos posteriores

Es importante que el nombre sea idéntico al nombre tipeado en Set Variable.

Tipos de Variables en Make

En Make, no todas las variables son iguales. Hay 4 tipos, y elegir mal te puede hacer creer que “se perdió el estado” cuando en realidad era otro alcance (scope).

1) System variables (variables del sistema)

Son variables que Make ya te da (no las creás vos).
No se pueden modificar ni borrar. Te sirven para cosas como:

• identificar la ejecución (execution ID)
• saber operaciones consumidas
• datos del escenario, organización, team, etc.

Se usan mucho en log, debugging y error handling (por ejemplo, mandar un email/slack con el link a la ejecución que falló)

2) Scenario variables (Set/Get variable)

Estas son las que estás usando en este artículo.

• Se crean dentro de un escenario
• Se usan como “memoria” durante la ejecución
• Se definen con Tools → Set variable (o Set multiple variables)
• Se recuperan con Tools → Get variable

✅ Ideal para: flags, resultados intermedios, cache dentro de una corrida.
⚠️ Importante: no son para “recordar cosas entre corridas”.

3) Custom variables (variables compartidas a nivel org/equipo)

Son parecidas a las scenario variables, pero viven “arriba”:

• Se crean a nivel Organization o Team
• Se pueden usar en escenarios dentro de ese alcance
• Están disponibles solo en planes Pro/Teams/Enterprise
• Se pueden actualizar por admin y también desde escenarios (vía Make API o módulo de update).

✅ Ideal para: valores que querés reusar en muchos escenarios sin copiar/pegar (ej: thresholds, IDs fijos, settings, toggles).

4) Incremental variables (contador)

Esto es otra cosa: un contador por escenario.

• Se crea por escenario
• Se incrementa con Tools → Increment function
• Puede configurarse para resetear por ejecución/ciclo o no resetear (para que siga entre ejecuciones).

✅ Ideal para: rotación (round-robin), numeración, turnos, alternar rutas, IDs secuenciales simples.

Ejemplo: flag para “frenar” iteración

Este ejemplo es el más útil cuando estás iterando o recorriendo resultados y querés frenar lógica “cara” cuando ya encontraste un match.

Objetivo

• Seguir buscando mientras AlreadyFound = false
• Cuando encontrás el match: setear AlreadyFound = true
• A partir de ahí: bloquear el resto de trabajo

Paso a paso

1. Set variable

• Name: AlreadyFound
• Lifetime: One execution
• Value: false

2. En la ruta/iteración, agregás un filtro antes de los módulos caros:

• “solo pasa si AlreadyFound es false”

3. Cuando aparece el match, hacés:

• Set variable AlreadyFound = true

Resultado: aunque sigan entrando bundles/iteraciones, el filtro evita que sigas gastando operaciones o hagas updates repetidos.

---

Listo: ya tenés la lógica. Ahora falta ejecutarla con un sistema claro.

Si recién estás empezando a diseñar automatizaciones, esta guía técnica funciona mucho mejor si ya tenés claro el marco base:

➡️ Leé también: “Cómo recuperar 10+ horas por semana automatizando tu trabajo (Trigger / Reglas / Resultado)”

Y si tu objetivo no es “entender variables”, sino implementar automatizaciones reales y sostenibles en 14 días con un sistema guiado, el siguiente escalón es el Sistema Firbot 10H.

Qué vas a lograr en 14 días:

• identificar tus 3 fugas de tiempo principales
• diseñar flujos simples
• implementar automatizaciones que realmente se usan en el trabajo real
• dejar armado un sistema repetible (para no depender de “motivación”)