Blueprint Runner: a self-hosted engine that speaks Make natively
Paste a Make.com blueprint export, keep the tokens in variables rather than the JSON, and run the scenario on your own infrastructure, with a per-module log of every request and output.

- module types supported
- 30+
- expression language
- Full
The problem
Per-operation pricing is fine until a scenario iterates. At volume, the bill stops tracking the value of the work and starts tracking the number of rows, and the usual response (restructuring the scenario to do less) eventually runs out.
The lock-in is not the platform, it is the blueprint format: the routers, iterators, aggregators and the whole expression language inside every double-brace. Rewriting that logic somewhere else is a project, not a migration.
And blueprints carry secrets. Bearer tokens pasted into HTTP module headers mean an export cannot safely be shared, version-controlled, or handed to anyone.
What we built
Execute the format, do not translate it
The engine reads Make blueprint JSON directly and implements the module set: HTTP with raw and urlencoded bodies, headers, query strings and error handling; the Airtable actions including search, create, update, upsert and arbitrary REST calls; and flow control across iterators, routers, if/else with merge, and merge filters. Unknown app modules are skipped with a log entry and emit an empty bundle, so a partially supported blueprint still runs end to end instead of halting.
The expression language, properly
Module references with backticked keys and array mapping, one-based indexing, and the function library: date formatting and arithmetic, conditionals, string and array operations, hashing, encoding, plus Make's filter operators and its OR-of-AND-groups condition matrix. This is the part that makes a blueprint portable rather than merely readable.
Secrets out of the JSON, by button
Tokens live in variables referenced as double-brace var names, and connections map Make's numeric connection identifiers to credentials. A scan-and-extract action finds bearer tokens and API keys hardcoded in a pasted blueprint, moves them into variables, and rewrites the JSON to reference them, so the blueprint becomes safe to commit. Server-side environment variables can supply the same values, with anything entered in the interface overriding them.
A canvas, not just a JSON box
The default view renders the blueprint as wired module nodes with routers and branches fanning out, curved connectors, branch labels and filter badges. Clicking a node opens a type-aware inspector; a plus between modules opens a grouped picker. The canvas and the raw JSON are two views of the same data, so anything built visually exports as a Make-compatible blueprint.
Proving it against a real scenario
The self-test mocks a clinic API and Airtable and asserts a genuine end-to-end scenario: new-patient creation, visit deduplication through a merge filter, record creation, linked-record append using the string-surgery idiom this actually requires in practice, a filtered route on primary diagnosis, and cross-bundle text aggregation.

The outcome
Scenarios run on infrastructure you control, with no per-operation meter and a dry-run mode that shows every resolved request before anything is called.
Each run produces a per-module log (status, request with auth headers redacted, output, timing and bundle position), which is more visibility than the original offers.
Blueprints become version-controllable artefacts, because the credentials are no longer inside them.
Deploys as a single Next.js app with no database; state lives in the browser until you decide it should not.
Built with
- Next.js
- TypeScript
- Make blueprint format
- Airtable API
- Vercel
Page copy drafted with AI assistance. Skofi is accountable for it. Editorial policy
Have something shaped like this?
If any part of the above resembles a problem you are living with, a short call is the fastest way to find out whether it is the same problem underneath.
What happens on the call
- 15 minutes, no deck
- We map the process on the call
- A written scope, or an honest no