blueprint-runtime / Make.com behaviors

How Make.com actually evaluates mappings, filters and routers

Make doesn't publish a specification for its expression language. Everything below was recorded from real runs in a Make account (eu1, Free plan) in October 2026 while building blueprint-runtime, an open source offline test runner that reproduces 71 of 79 of those runs exactly. Each answer is backed by a recording listed in the project's evidence notes.

• What does [] do in a Make.com mapping?
• How does if() decide what is true in Make?
• How does = compare values in a Make expression?
• Why does "42" + 1 give "421" in Make?
• How do arrays and empty values turn into text in Make?
• How do Make filters compare text, numbers and empty values?
• Does Make run every router route that matches?
• How do iterators and aggregators run in Make, and what do they cost?
• What does now return in Make?
• What happens when an expression fails in Make?

What does [] do in a Make.com mapping?

• [] reads the first element only. It does not map over the array: {{1.people[].name}} gave Ann, the first person's name, in a text field, as a function argument and in an iterator's array field.
• To read every element, use map(). It keeps items without the key as empty entries: join(map(people; "name"); "|") gave Ann|Bob||.
• [] on an empty array, a missing value or an object reads as missing. On text it returns the text itself.
• Array indexes start at 1: arr[2] is the second element.

How does if() decide what is true in Make?

• It uses JavaScript truthiness. The texts "false", "0" and "abc", the number -1, [] and {} are all true. Empty text, 0, null and missing are false.
• if() is lazy: the branch it doesn't pick is never evaluated, so an error there doesn't fail the module.
• ifempty() falls back only on empty text, null and missing. [], {}, 0 and false come back unchanged.

How does = compare values in a Make expression?

• Like JavaScript's loose ==: "42" = 42, 42 = "42.0", 0 = false and null = missing are all true.
• It is case-sensitive ("a" = "A" is false), true = "true" is false and missing = "" is false.
• Dates are compared as objects, so now = now is false.

Why does "42" + 1 give "421" in Make?

• + adds only when both sides are numbers. Anything else is joined as text: "42"+1 is "421", true+1 is "true1" and missing+1 is "1".
• * converts like JavaScript, with missing as 0: "42"*1 is 42, "abc"*2 is NaN and missing*2 is 0.
• The operators +, - and * use exact decimal arithmetic (0.1+0.7 is 0.8, 1.005*1000 is 1005), but functions don't: sum() of 0.1 and 0.2 gives 0.30000000000000004.
• round(2.5) is 3 but round(-2.5) is -2, like JavaScript's Math.round. 42/0 is Infinity, not an error.

How do arrays and empty values turn into text in Make?

• An array mapped into a text field is joined with a comma and a NO-BREAK SPACE (U+00A0), not a normal space: c, a, b.
• Functions convert arrays differently: upper() of the array a, b gives A,B, with a plain comma.
• A mapped field that evaluates to empty text is stored as null in the module's bundle.
• length() counts UTF-16 code units, so an emoji counts as 2. upper("ß") is "SS".
• Text must be quoted. A bare word parses but isn't text: indexOf(s; o) returns -1. Backslash is not an escape character, and a \" inside a string made Make reject the whole scenario.

How do Make filters compare text, numbers and empty values?

• Text operators are case-sensitive unless you pick the case-insensitive variant, and they don't trim: " a" doesn't equal "a".
• Number operators read "150" as 150 and "1e3" as 1000, but empty text, null, missing, "abc" and "150abc" are not numbers, so every comparison with them is false. That matches neither JavaScript's Number() nor parseFloat().
• Exists is false only for missing, null and empty text. 0 and an empty array [] exist.
• Conditions joined by AND stop at the first false one.

Does Make run every router route that matches?

• Yes. Routes are checked in order, and every route whose filter passes runs, each one to the end before the next starts.
• The fallback route runs only when no other route passed.
• The router itself uses no operation.

How do iterators and aggregators run in Make, and what do they cost?

• Each bundle goes through the rest of the flow before the next bundle starts (depth-first).
• An empty or missing array gives 0 bundles, but a Text aggregator still outputs one bundle with empty text.
• A null element in the array fails the iterator: TypeError: Cannot convert undefined or null to object.
• After the aggregator, fields of the iterator and of the modules between them read as missing.
• Operations: the iterator counts 1 however many bundles it emits, each bundle through a later module counts 1, the aggregator 1, a router 0 and a module a filter stopped 0.

What does now return in Make?

• The time each module starts, to the millisecond, not the time the scenario started. After a 3-second Sleep, the next module's now was 3 seconds later.
• parseDate() and formatDate() without a timezone use the organization's timezone.
• addMonths() clamps to the end of the month: January 31 plus one month is the last day of February.

What happens when an expression fails in Make?

• The module fails and the run stops. A webhook caller gets HTTP 500 with Scenario failed to complete.
• Make lets you start a scenario with an expression it can't evaluate. The first run fails, Make switches the scenario off, and webhooks sent after that wait in the queue (50 on the free plan).
• A Webhook response with an empty body reaches the caller as 200 Accepted, the same text Make sends for a queued webhook.
• A trigger run that emits no bundles doesn't appear in the scenario's log at all.

Make can change its behavior. These are dated observations from one account, not Make's documentation. Where no run showed how Make behaves, blueprint-runtime refuses the case instead of guessing.