Make Error Handlers: Break, Rollback, Commit, Ignore, Resume
What each Make error handler directive does to the run, the bundle and your data, when to use it, and the scenario settings that decide if a failure is lost.
In Make, an error handler is a route you attach to a module; it runs when that module fails and ends in a directive that decides what happens next. Ignore and Resume let the run carry on, Commit and Rollback stop it, and Break sets the failed bundle aside as an incomplete execution so it can be retried. Which one you pick decides whether a client's order or lead is handled, skipped or lost.
What happens with no error handler
When a module without an error handler fails, the run stops with an error. If the scenario keeps failing, Make switches it off after the number of consecutive errors set in the scenario settings, and every run after that simply does not happen until someone turns it back on.
Two scenario settings matter here, and both are worth checking before a handover:
- Allow storing of incomplete executions. With it on, a run that fails can be kept and resolved or retried later instead of being lost.
- Number of consecutive errors. How many failed runs in a row it takes for Make to switch the scenario off.
The five directives
Add an error handler by right-clicking a module and choosing Add error handler, then end the route with one of these:
| Directive | The run | The failed bundle | Use it when |
|---|---|---|---|
| Ignore | Carries on with the next bundle | Skipped | One bad record must not stop the rest |
| Resume | Carries on as if the module had worked | Replaced by output you specify | A sensible default value exists |
| Commit | Stops, marked as a success | Not processed further | Partial work is fine to keep |
| Rollback | Stops, marked as an error | Not processed further | Partial work must be undone |
| Break | Stops for that bundle | Saved as an incomplete execution, retried automatically if you set it to | The failure is likely to pass, such as a timeout |
Ignore
The error is swallowed: the bundle that failed is dropped and the scenario goes on. The run looks successful, so nobody will notice the skipped record unless the handler route does something visible first, such as posting to Slack or adding a row to a log sheet before the Ignore.
Resume
You give the output the failed module should have produced, and the run continues with it. Good for optional enrichment (a missing company size becomes "unknown"), dangerous for anything that matters, because the substitute value flows into everything after it.
Rollback vs Commit
Both stop the run. Commit keeps what was already done and marks the run as a success; Rollback reverts the changes made by modules that support transactions and marks the run as an error. Most app modules cannot be undone, so Rollback mainly protects data stores and databases: an email that was sent stays sent.
Break
Break is the safest choice for outside services. The failed bundle is stored as an incomplete execution (this needs Allow storing of incomplete executions on), and with automatic completion turned on, Make retries it after the interval you choose, for the number of attempts you set. If the retries run out, it waits in the list of incomplete executions for someone to resolve.
A sensible default for client scenarios
- Turn on Allow storing of incomplete executions for every production scenario.
- Give every module that calls an outside service an error handler that ends in Break with automatic retries.
- Where skipping a record is acceptable, log it first and then Ignore, so the skip is visible.
- Keep Resume for values that are truly optional.
See where a scenario will lose data
The scenario editor shows error handler routes, but not what each one means for the client's data, and it never shows the modules that have no handler at all. Importing the blueprint into VamimiAI's Make scenario diagram draws each error handler route dashed and ends it in what its directive does, in plain words such as "Saved to incomplete runs for a retry". The checks on import flag modules with no error handler and scenarios that do not keep failed runs.
Then create the handover document so the client sees the same picture, with a table of what happens when each module fails. Scenario already switched off, or seeing "not enough space to add a new incomplete execution"? See Make scenario deactivated. Building on n8n as well? The n8n error handling guide covers the same ground there.
Questions
What is the difference between Ignore and Break in Make?
Ignore drops the failed bundle and lets the run carry on, so the record is skipped. Break stops processing that bundle and saves it as an incomplete execution, so it can be retried automatically or resolved by hand.
Why did my Make scenario turn itself off?
Make switches a scenario off after the number of consecutive errors set in its settings. Add error handlers to the modules that fail, and keep incomplete executions so failed runs are not lost.
Does Rollback undo everything the scenario did?
No. Rollback reverts changes only in modules that support transactions, such as data stores. Actions in most apps, like a sent email or a created CRM record, cannot be undone.