Step-by-Step Error Handling in Make (Integromat)

• Enable Built-in Error Handling: Open your scenario’s editor and click on the module where the error occurred. In the module settings, enable the option "Continue operations on error" (sometimes noted as "Ignore errors" or "Error handling"). This allows you to capture the error details and decide how to proceed, instead of halting the entire scenario.
• Add a Dedicated Error Handler: After enabling error continuation, add a new module specifically to handle the error. For example, add a "Logger" module to capture and log error details or a custom module that sends an email alert. Then, connect the error handler on the module’s error branch. This way, if an error occurs, you can review its details later and even execute corrective actions.
• Use a Router for Alternate Flows: Insert a "Router" module right after the module that may fail. Configure one branch to continue the normal process and another branch that catches errors. In the error branch, use a filter with a condition such as "Execution status equals error" to separate normal data from error data. This clear division helps you process successful outputs while addressing errors appropriately.
• Implement Conditional Logic for Recovery: In the error branch, add modules to process the error data. For example, you can set up conditional modules that check the error details and attempt a recovery step. If the error is temporary (for instance, due to an API rate limit), use a "Delay" module for waiting a few seconds before reattempting the call. This approach minimizes disruption to your scenario.
• Retry Mechanisms with Data Stores: If you frequently encounter intermittent errors, consider saving the input data that caused the error to a "Data Store" module. Then, use a scheduled scenario to automatically retry processing the saved data. This strategy allows you to automatically recover from errors without manual intervention.
• Test and Monitor the Scenario: Once you have configured error handling, re-run the scenario in test mode. Observe both the normal and error branches to ensure that each follows the intended flow. Use the execution logs provided by Make to inspect details like error codes and messages, which help fine-tune your error handling steps.

Example: Implementing a Retry with a Delay

• Add a Delay Module in the Error Branch: Suppose you’re calling an external API. In the error branch, insert the following delay configuration before retrying:

// This example demonstrates setting up a delay before retrying an API call in Make
// Configure the Delay module to wait for 10 seconds
let delaySeconds = 10; // time in seconds to wait before retry attempt
// After delay, route the scenario back to the API call module for a retry
return delaySeconds; // This return value can be used in your conditional flow

• Save Data for Future Retries: In the same error branch, attach a Data Store module to save the error payload. Later, a scheduled scenario can load this data and reprocess it. This approach ensures that no valid data is lost even when an error stops the normal flow.

Final Testing and Monitoring

• Simulate Scenarios: Use the test-run feature in Make to simulate both successful and failing operations. This helps ensure that your error branch logic works as expected.
• Monitor Logs: Regularly check the scenario logs and Data Store entries to verify that errors are being handled correctly. If needed, adjust delay times or add more detailed logging to clarify the error details.