Productivity & Workflows
Make Incomplete Executions: Retry a Failed Module Without Losing the Original Run Context
Distinguish retrying a saved failed run from resolving bad mapping or replaying the current scenario. Reconcile bundles, original context and uncertain external writes.
A Make incomplete execution lets you continue from the failed module with the saved run context. Before retrying, identify which bundles already finished, check whether the failing operation created anything externally, and decide whether the original settings are still appropriate. A temporary interruption may justify Retry; a bad mapping usually requires opening the saved execution, correcting its module settings, and resolving it with the original input.
This documentation-based guide from LandOffer.ai uses fictional cases, not a Make account test. The important distinction is between recovering a particular unfinished run and starting today’s scenario again. The examples preserve that distinction even when the live scenario has changed, and keep uncertain side effects open until someone can reconcile them.

Identify the saved execution before choosing an action
Start with the scenario’s Incomplete executions tab. Match the execution ID, creation time, failed module, error, and original business record. Open Details and inspect the saved execution. Use the history log to investigate, but do not assume a log entry alone contains a runnable blueprint.
Make Academy explains that incomplete executions retain data and the blueprint from the failed run. Its distinction matters when a colleague has since edited the scenario: the current diagram may describe tomorrow’s processing rather than the operation you are recovering. Incomplete execution storage is disabled by default. If the relevant execution was never saved, this recovery path may not exist.
Record the current status and attempt count before choosing a recovery action. Pending means a retry is scheduled; In progress means an attempt is underway. Coordinate with the responsible owner rather than launching a second recovery while another attempt may be running. A screenshot of an earlier error cannot establish the current retry state.
Also check whether preserving payloads is allowed for this workflow. The feature retains information for recovery; confidentiality and storage settings affect what is available. Do not enable retention or copy sensitive bundle contents into a support ticket merely to reproduce this guide. An authorized owner must resolve that trade-off under the organization’s rules.
Separate the original blueprint from the surrounding environment
Retry is documented to restart at the failed module with the configuration from the failure. Editing the live scenario does not by itself establish that a saved execution will use the new mapping. When settings need correction, Make documents a separate manual Resolve path inside the incomplete execution.
There is an additional current setting worth checking: Use updated variable values. Make’s Scenario settings page distinguishes using current team and organization variable values from those active during the original run. Record that choice with the recovery decision. A preserved blueprint is not a promise that every environmental value, remote record, credential, or permission remains unchanged.
For example, a destination may have been renamed or an approver may have withdrawn a request since the error. Recovering the old input faithfully could now perform the wrong business action. Confirm that the original work is still wanted, and that the person authorizing recovery understands which version will run.
Keep two change records if needed: a narrowly scoped repair to this saved execution, and a separately reviewed correction to the live scenario. The former can complete old work without proving that future runs are fixed. The latter can improve future processing without completing the old failure. Give each its own evidence and owner so completing an old request does not conceal an untested defect in future processing.
Worked asset: account for every bundle in a three-module flow
The following is an authored fictional model, not output from Make. Mira owns a facilities workflow that receives room-sign requests, creates a print-queue record, and posts an internal preparation notice. No real printer, queue, or messaging service was used.
The three modules are M1 Receive request, M2 Create print record, and M3 Post preparation notice. The case assumes incomplete execution storage was enabled and the workflow permits later bundles to proceed; do not transfer that assumption to an ordered scenario. Each request has a stable request ID for reconciliation, not a claimed built-in Make deduplication key.
Original run R-41 began at 09:00 UTC on October 26, 2026. Its blueprint B-12 maps the requested copy count to M2. The saved execution I-41 concerns request SIGN-202, whose copy-count input is the string two. For this example, the destination’s documented validation response explicitly says it rejected the request before creating a record. That fictional response is stronger evidence than a generic timeout.
| Bundle and request | M1 state | M2 state | M3 state | Recovery disposition |
|---|---|---|---|---|
| 1: SIGN-201, quantity 1 | Received | Created queue record P-901 | Notice N-901 posted | Completed; exclude from replay |
2: SIGN-202, quantity two |
Received; original input saved | Validation failed; no record created in this case | Not reached | Recover I-41 from M2 after approved correction |
| 3: SIGN-203, quantity 3 | Received | Created queue record P-903 | Notice N-903 posted | Completed later in the original run; exclude from replay |
For SIGN-202, the remaining work is to complete M2, then pass its successful result to M3. M1 already received that request. Bundles 1 and 3 already produced their external records and notices. Resending all three source requests would create a separate duplication question that continuing I-41 does not require.
Mira’s state record therefore contains three received requests, two completed queue records, two completed notices, one failed M2 operation, and one M3 operation not reached. It does not label the entire run “nothing happened.” A local synthetic fixture verifies those state counts and the final one-record-per-request reconciliation. It does not execute Make, simulate its scheduler, or verify a destination’s write behavior.
The current scenario has meanwhile become B-13, adding a new destination queue for future requests. I-41 still represents B-12. Mira records the old destination as correct for SIGN-202 because the request’s approved print location has not changed. Without that confirmation, the recovery should remain on hold even if a mapping fix appears straightforward.
Worked asset: repair one field and reconcile the result

Mira asks request owner Cole to confirm the intended quantity. Cole confirms two copies against the fictional request record. The repair decision is to use numeric 2 for this one execution’s failed mapping, preserving SIGN-202 and its original destination. This is not an instruction to replace every future quantity with a constant.
Make’s documented manual sequence is to open the incomplete execution, correct the failing module, save its updated settings, and use Run once. Processing starts at the failed module with the original input. Read that control in the saved execution’s context; a similarly named control in the live scenario is a different starting point.
The completed table below describes an illustrative outcome. None of these UI actions or remote writes were performed during this article’s preparation.
| Check | Filled illustrative record | What it establishes |
|---|---|---|
| Identity before repair | I-41; R-41; SIGN-202; failed M2; B-12 | The intended saved execution, not the edited B-13 live flow |
| Original input | Request SIGN-202; copies two; original print location |
The source payload has not been silently replaced |
| Approved correction | Cole confirms 2; Mira replaces only the failed copy-count mapping with numeric 2 in the saved execution |
A bounded field repair, with approval distinct from execution |
| Variable decision | No team or organization variables are used by this fictional three-module flow | Updated-variable behavior cannot explain this example’s result |
| Result at M2 | New queue record P-902 references SIGN-202 and quantity 2 | The intended business record exists in the story |
| Result at M3 | Notice N-902 references P-902 | The downstream notice corresponds to the recovered record |
| Saved execution | I-41 is Resolved in the illustrative result | Technical completion of that saved recovery |
| Final reconciliation | P-901/P-902/P-903 and N-901/N-902/N-903 each occur once by request ID | Three fulfilled requests, without repeating the two completed bundles |
| Separate future repair | B-13 quantity validation change remains untested and separately assigned to Mira | Recovery has not been misreported as a verified permanent fix |
A Resolved status still needs business-result reconciliation. It is agreement between the saved execution identity, corrected quantity, queue record, and notice. An execution can finish technically while still writing to an unintended destination or producing a business duplicate.
In an actual authorized recovery, retain approved references to those results and the before/after mapping. Do not retain unnecessary request contents. If a later module fails, inspect the newly created incomplete execution and its new failure boundary; do not repeatedly rerun the earlier successful operation just because the overall workflow remains unfinished.
A timeout needs a different decision from rejected input
Consider a second fictional case, I-58, for SIGN-208. M2 times out after sending a create request. The scenario’s error proves the module did not obtain a successful response. It does not prove the destination created nothing. M3 has not been reached, but M2’s external outcome is unknown.
Mira searches the authorized destination record view using SIGN-208. The lookup finds P-908 with the expected request ID and quantity. Mira records “SIGN-208 found as P-908; module response missing” and holds the retry. This is a completed diagnostic decision to avoid another create operation, not a completed Make recovery. The saved execution remains unresolved in the fictional record.
A colleague proposes retrying because the error is temporary. Mira asks the integration owner whether that specific create endpoint supports a verified idempotency mechanism, whether it was used in the original request, and how an existing result can be reconciled with the remaining flow. A unique request field alone is not evidence that the destination rejects duplicates.
The integration owner has not answered, so the record explicitly leaves downstream continuation undecided. Do not invent a substitute module output or mark the execution Resolved to make the case look finished. Choosing not to retry yet can be the correct operational result when a write’s outcome is uncertain.
Check scheduled retries, ordering, and closure separately
Make documents automatic retries for supported errors, including RateLimitError, ConnectionError, and ModuleTimeoutError, and for appropriately configured Retry error handlers. Check the actual attempt state before any manual recovery. “I have not clicked Retry” does not mean no retry is scheduled.
Ordering is another separate control. Current settings explain that Process data in order pauses new runs until incomplete executions are resolved when enabled. When it is disabled, later work can proceed according to the scenario’s schedule. This is why the first case states its ordering assumption and reconciles bundle 3 instead of assuming every later request is waiting.
Before closing a recovery, confirm the business result, unresolved downstream work, and whether future processing needs a separate repair. Record the owner, next authorized check, and evidence still needed for each open item. An assigned follow-up is not a completed repair. If the work is no longer required, an authorized owner can consider deletion, but Make documents that deleted incomplete executions cannot be restored. Deletion is not evidence of delivery.
For your next recovery, first create the small state map: saved execution ID, failed boundary, already-created results, remaining work, and any unknown side effect. Then select the narrow action supported by that evidence. More workplace workflow guides are available through LandOffer.ai; this guide does not operate Make or validate your organization’s recovery controls.
Sources and Further Reading
- Make: Manage incomplete executions — Retry, manual Resolve, original input, later-module failure, and irreversible deletion. Undated; checked October 25, 2026.
- Make Academy: Incomplete executions — Saved blueprint and data, original versus current scenario, and worked recovery mechanics. Updated May 21, 2026; checked October 25, 2026.
- Make: Scenario settings — Current ordering, confidentiality, storage, and updated-variable controls. Undated; checked October 25, 2026.
- Make: Automatic retry of incomplete executions — Supported errors, retry scheduling and completion states. Undated; checked October 25, 2026.
- Make: Incomplete executions — Storage disabled by default and usage allowance. Undated; checked October 25, 2026.


