- Every scenario fails eventually. The question is whether someone finds out.
- Make offers five directives: Ignore, Resume, Commit, Rollback and Break.
- Use Break with stored incomplete executions for temporary failures.
- Send failure alerts somewhere a person will see them the same day.
A Make scenario that works in testing has only proved that it handles perfect data on a good day. In production it will meet an empty field, a rate limit, an expired connection and an app that is briefly offline. Without error handling, the scenario stops, and after repeated failures Make switches it off. If nobody is watching, the first sign is a customer asking where something is.
This guide covers the tools Make gives you and how to use them.
What happens by default
When a module fails and has no error handler, the run stops and is marked as an error. Earlier modules in the same run may already have done their work, so you can be left with a half-finished process: an invoice created but never sent, for example. Designing for failure means deciding in advance what should happen at each point where that is possible.
The five error directives
Right-click a module and add an error handler to attach a separate route that runs only when that module fails. The route ends in one of five directives.
| Directive | What it does | Use it when |
|---|---|---|
| Ignore | Skips the failed item and carries on with the rest | The step is optional and a miss is harmless |
| Resume | Supplies a substitute output and continues the flow | A sensible default exists, such as “Unknown” |
| Commit | Stops the run and keeps the changes made so far | What has been done should stand |
| Rollback | Stops the run and reverts changes where modules support it | Partial results would be worse than none |
| Break | Stores the run as an incomplete execution to retry later | The failure is probably temporary |
Retries for temporary failures
Timeouts and rate limits usually fix themselves. For these, use the Break directive and turn on storage of incomplete executions in the scenario settings. Make can then retry the run automatically after an interval you set, a limited number of times, and anything still failing waits in a queue for a person to resolve. No data is lost while it waits.
Alerts someone will actually read
Before the directive on any error route, add a module that reports the failure: a message to a team channel or an email to a monitored address. Include the scenario name, the module that failed, the error text and a link to the run. An alert that says only “something went wrong” will be ignored by the third time it appears.
Stop bad data at the door
Many errors are predictable. Put a filter after the trigger that checks that required fields are present and correctly formatted, and send records that fail to a review list instead of into the main flow. Catching a missing email address in the first step is far cheaper than discovering it five modules later.
Make repeat runs harmless
A retried run must not create a second invoice. Before creating anything, search for it first, using a stable identifier such as an order number, and update the existing record if you find one. This single habit removes most duplicate problems.
Checklist before go-live
- Every module that calls an external app has an error route
- Temporary failures use Break, with incomplete executions stored
- Failure alerts go to a channel that is read daily
- Required fields are validated straight after the trigger
- Create steps search first, so repeats don’t duplicate
- The scenario has been tested with bad data on purpose
- Modules are named clearly and the scenario has notes
- Someone is named as the owner
Make’s interface and settings change over time, so check the current documentation for exact names and options. The principles carry over to other platforms as well, which is one reason they matter more than the choice of tool. For that decision, see Make vs n8n vs Zapier.