Long-Running API Jobs: Compare 6 Workflow Tools
By Lazar Milićević, senior engineer, BizFlowAI
Scope: Comparison of documented features; this article does not present comparative test results.
Your supplier API accepts a job now, returns a result later, and occasionally fails halfway through. You need to know whether your workflow will still be there tomorrow—and what happens if the supplier completed a request just before your worker lost its connection.
The short answer: Choose Temporal when you need durable, code-defined control over a long-lived process; Inngest when saved step results fit an event-driven application; Trigger.dev when long-running tasks and approval waits are central; AWS Step Functions Standard when the work already lives in AWS; n8n when a visual workflow and persisted waits are sufficient; and Zapier for simpler delayed automations, not as your default coordinator for a complex external job. The deciding test is not whether a tool can wait. It is whether it can recover safely after an API call succeeds but the workflow fails before recording that success.
The decision matrix: what each tool actually gives you
This article does not present comparative tool-test results. The matrix below summarizes documented behavior, not completion rates, recovery scores, or results from identical live deployments. Use it to shortlist tools; use the test procedure later in this article to make your final choice.
| Tool | Retry boundary to examine | Documented way to wait or persist progress | Human or external callback | Main decision point |
|---|---|---|---|---|
| Temporal | Failed Activities retry by default; an entire Workflow Execution does not retry by default | Long-lived workflow state; Workflow Execution Timeout is unlimited by default | Signals can change a running workflow’s state | Strong fit when you can own workflow code and need explicit control over each operation |
| Inngest | A retry of a later failed step reuses saved results from completed steps | Durable steps and sleeps; total run limits depend on plan | Design an approval event or other resume path into the function | Strong fit when durable steps map cleanly to your application events |
| Trigger.dev | A retried task can restart its run function from the beginning | Supports waits; maxDuration counts compute time, not time waiting for a timer, approval token, or child task |
Approval token can resume a run or time out | Check which calls could repeat when the task restarts |
| AWS Step Functions Standard | Configurable Retry rules on Task, Parallel, and Map states |
Standard workflows can run for up to one year | Task-token callback resumes after SendTaskSuccess or SendTaskFailure
|
Strong fit when AWS services and explicit state-machine definitions suit the team |
| n8n | Evaluate recovery at the node and execution level for your design | Wait node saves paused execution data to the database and reloads it on resume | Wait can resume from a webhook or submitted form | Useful when operators need a visual workflow and straightforward handoffs |
| Zapier | Test the behavior of the specific Zap and connected app | Delay can hold a task for at most 30 days | Build the approval or external-status path from the available Zap steps | Suitable for simpler flows; a changed Zap can prevent a delayed run from continuing |
The sources for those distinctions are the Temporal retry documentation, Inngest durable-workflow documentation, Trigger.dev’s retry discussion, AWS error-handling documentation, n8n’s Wait-node documentation, and Zapier’s Delay documentation.
Start by drawing your job as submit → wait → check status → review if needed → publish result. Mark every step that changes something outside the workflow: submitting a vendor job, creating an invoice, sending an email, or updating a customer record. Those marked steps determine whether a retry is safe.
Retries: the real problem is the uncertain outcome
A retry means “run something again,” not “guarantee the external action happened exactly once.” If an API accepts a submission and your worker fails before saving the response, the workflow may reasonably retry—while the supplier may already be processing the first submission.
Consider a small business that sends files to an external processing service. The service accepts POST /jobs, then completes work asynchronously. A failure immediately after the POST creates two possible histories:
- The service never received the request. Resubmitting is necessary.
- The service accepted the request, but the workflow lost the response. Resubmitting could create a duplicate job.
The workflow engine cannot resolve that ambiguity on its own. Prefer a supplier-provided idempotency key where available. Otherwise, use a stable job identifier and a supplier lookup endpoint, if one exists. If neither exists, route uncertain submissions to an operator rather than claiming automatic recovery is safe.
The products differ in what they replay. Temporal retries failed Activities by default, but not an entire Workflow Execution by default. That makes the Activity boundary important: keep an external submission in an Activity, and decide which errors deserve another attempt. Inngest reuses saved results from completed steps when a later step fails, so a successfully recorded submission step need not run again merely because processing failed afterward. Trigger.dev warns that a task retry can restart its run function from the beginning; calls made earlier in that function need a deliberate duplicate-prevention strategy.
In Step Functions, Retry rules apply to Task, Parallel, and Map states. A retrier without MaxAttempts uses the documented default of three retries. Do not leave that default unexamined for a charge, submission, or customer-facing message. For n8n and Zapier, build and test the actual workflow you intend to run rather than assuming a platform-level retry setting protects each external side effect in the same way.
A useful design record for every external call is:
operation: submit_supplier_job
stable_job_reference: derived_from_source_record
idempotency_support: confirm_with_supplier
lookup_after_unknown_response: required_if_available
retry_on: explicitly_classified_transient_errors
unknown_outcome: hold_for_reconciliation
That is a planning checklist, not configuration you can paste into any of the six tools. Its purpose is to force an answer before production: How will we tell “failed to submit” from “submitted but failed to record”?
Timeouts: a long workflow is not a long API request
Workflow lifetime, an individual step’s runtime, the hosting service’s timeout, and an outbound HTTP request’s timeout are different controls. A tool may keep a job record for months while still requiring each API call to finish quickly and each wait to resume before a separate limit.
The documented ceilings make that distinction concrete:
| Tool | Documented limit or behavior | What it does not establish |
|---|---|---|
| Temporal | Workflow Execution Timeout is unlimited by default | That an individual external request should have no deadline |
| Inngest | Maximum function-run length, including sleeps: 30 days on Free, 90 days on Pro, 366 days on Business | That one step or its host can run for that entire period |
| Inngest | Step timeout is up to two hours; the function host may impose a shorter timeout | That an outbound API call automatically stops at the deadline you want |
| Trigger.dev |
maxDuration counts compute time, not time waiting for a timer, approval token, or child task |
That every deployment mode handles waiting or billing identically |
| AWS Step Functions Standard | A workflow can run for up to one year | That a single task or API connection can stay open for one year |
| Zapier Delay | A delay can last at most 30 days; its shortest configurable delay is one minute | That Delay is a substitute for a fast polling loop |
Set an HTTP timeout for the supplier call, a separate deadline for the supplier job, and another deadline for any human review. When the supplier job exceeds its deadline, move it to an explicit exception state; do not keep polling without a decision.
Inngest notes that its finish timeout does not interrupt a step already executing. That is a good reason to set a timeout on the external API request itself when you need a strict deadline. Check your host’s limits as well: a durable workflow does not remove the limits of the compute running each step.
State persistence: design for a restart you did not schedule
Persisted state should let a fresh process answer three questions: Which business job is this? What completed? What action is safe next? If you cannot answer those after a restart, the workflow is not recoverable merely because its timer survives.
Temporal models a long-lived Workflow Execution and can receive Signals that change its state. Inngest’s saved completed-step results help a resumed run avoid repeating those steps. The n8n Wait node saves paused execution data in its database and reloads it when its resume condition is met. These are different mechanisms, but each can support a process that outlives the worker that started it.
Persistence still needs a business record. Store or reliably reconstruct:
- The source record and stable external-job reference.
- The external service’s job identifier, if submission was confirmed.
- The last confirmed business state, not just the last node that ran.
- The next deadline and what should happen when it passes.
- An approval decision and who made it, if approval changes the outcome.
- A reconciliation status for calls whose outcome is unknown.
Be careful with “completed” flags. Marking a step complete before the external call risks losing the work. Marking it complete after the call leaves a window in which the external action succeeded but the flag was never saved. An idempotency key, lookup, or reconciliation path closes the business gap; a database flag alone does not.
There is an operational difference between a workflow being durable and the business process being recoverable. Test both. An operator should be able to find a stuck job, identify its last confirmed external effect, and choose whether to retry, reconcile, cancel, or escalate without reading an ambiguous stack trace.
Human approval: pause safely, then check what changed
A useful approval step preserves the job’s context, resumes the correct run, and handles a missing or late decision. It also rechecks facts that may have changed while the job waited—for example, whether an invoice is still unpaid or a customer request has already been handled.
The named tools offer different primitives. Temporal Signals can update a long-lived workflow’s state. Trigger.dev supports an approval wait using a token that resumes the run when completed or times out. Step Functions Standard supports callbacks through task tokens; the external process returns the token with SendTaskSuccess or SendTaskFailure. In n8n, a Wait node can resume on a webhook call or submitted form, with an optional wait-time limit.
These mechanisms provide a way to resume. They do not decide your approval policy. Specify who may approve, what information they see, what happens on rejection, and what happens if nobody responds. Avoid putting a powerful callback token into a broadly accessible email or document; treat a token that can advance a job as a credential for that job.
Zapier’s Delay can be useful in a simpler human-in-the-loop process, but check its change behavior before using it as the holding point for important work. Zapier says a delayed run will not continue after resuming if its Zap was changed during the delay. If the process must survive workflow edits, that condition belongs in your acceptance test.
A reproducible test before you commit
This article does not present results from identical test deployments or recorded outcomes from injected failures. A table of completion times or recovery rates would be invented. The following protocol gives you a way to produce results for your API job instead.
Build the same business flow in each shortlisted tool: submit a job, record its identifier, wait for completion, request approval if a review condition is met, and record the final outcome. Use the same test service, inputs, approval decisions, and failure points. Record tool plan, configuration, deployment mode, host, and tool version alongside results; those details can change the outcome.
Run these failure cases deliberately:
- Failure before submission. Verify whether the job is retried and whether the external service received anything.
- Submission accepted, response lost. Make the test service record the request, then return no usable response. Check for duplicate external jobs and whether the workflow flags an uncertain outcome.
- Failure after a recorded submission. Restart or fail the next step. Check whether the tool repeats the submission or uses its recorded result.
- Long external wait. Resume the job after the worker that started it is gone. Verify that the correct job and context return.
- Approval delayed or rejected. Confirm the run does not proceed on an absent approval, and record what happens at the configured deadline.
- Workflow changed while waiting. Deploy a change, then resume a waiting job. Record what happens rather than assuming old runs use new definitions safely.
- Supplier never finishes. Verify the business deadline produces a visible exception an operator can resolve.
Use a result sheet that separates observations from documentation:
| Tool and configuration | Failure injected | External jobs created | Resumed at intended step? | Operator action needed? | Evidence |
|---|---|---|---|---|---|
| Fill after test | Fill after test | Measure | Observe | Record | Execution log and supplier record |
A pass is not simply “the workflow ended.” For a submission, inspect the supplier’s records for duplicates. For approval, inspect the decision and the action that followed. For a timeout, confirm the job reached a state someone can find and resolve. Check current plan limits and pricing in each provider’s official documentation before buying. This comparison does not present verified settings for a specific account or a calculation of charges.
How BizFlowAI approaches this
I’m a senior engineer who builds AI automations for solopreneurs and small teams. For a long-running API job, I recommend mapping the external effects of each call and its uncertain outcomes before drawing a diagram of connected apps. Submission, waiting, approval, and recovery each need a clear owner and an observable state.
I would choose the tool only after testing the failure at the hardest boundary: the external API may have accepted a request even though our workflow did not record the response. If that case cannot be reconciled, adding retries makes the system busier, not safer.
Work with BizFlowAI
If you'd rather have this built for you, that's what we do: production AI automation for solo founders and small teams — agents, integrations, and document pipelines that actually ship.
Request a free discovery call — 30 minutes, we map the highest-ROI automation in your workflow. No pitch deck, just engineering.
More guides like this on the BizFlowAI blog.
Top comments (0)