Page 2 of 6
How `ctx.sleep` collapses long-lived waits into one line by suspending the workflow against a durable timer promise.
Suspend a workflow for seconds, days, or years without holding a process open. The sleep is a server-backed timer promise; another worker resumes the workflow when the timer fires, even if the original worker is gone.
How a Redpanda-fed Python worker collapses head-of-line blocking and crash-resume into straight-line generator code by treating each message id as a durable promise id.
A Redpanda consumer kicks off one durable workflow per message and returns immediately. Each step is a checkpoint; a worker crash mid-deletion resumes from the last completed batch, and the record id deduplicates retries.
How a stateless Edge Function runs a stateful, checkpointed onboarding workflow keyed by user id.
A Supabase Database Webhook fires an Edge Function on user INSERT; Resonate makes the four-step onboarding workflow durable across function invocations, retries, and duplicate webhook deliveries.
How the fan-out / fan-in pattern collapses to four ctx.beginRun calls plus four yields when every branch is a durable promise.
Notify a customer over email, SMS, Slack, and push in parallel. Each channel is an independent durable checkpoint, so a retry of one branch does not re-send the others.
How an Express gateway dispatches durable work to a worker pool and lets clients poll a non-blocking status endpoint.
Accept an HTTP request, dispatch durable work to a separate worker process, and let the client poll for completion. The gateway holds no state; Resonate keeps the promise alive across worker crashes and restarts.
How a worker group plus a `poll://any@workers` target collapses service discovery, load balancing, and crash recovery into config strings.
Run multiple Rust workers in a named group and dispatch durable RPCs to any one of them. The Resonate Server handles service discovery, load balancing, and recovery; the worker code is one function and a group string.
How a Lambda handler hands a multi-step Python workflow to a long-running Resonate worker that survives Lambda's 15-minute timeout.
AWS Lambda has a hard 15-minute execution ceiling. Split the work: Lambda accepts the request and dispatches a durable RPC, and a long-running Resonate worker runs the multi-step workflow with each step checkpointed.
How a generator workflow suspends on a latent durable promise and resumes when an HTTP handler settles it by ID.
Block a Resonate generator workflow on human approval for an indefinite duration. The workflow yields a latent durable promise; an Express gateway settles it from outside, and the suspension survives worker crashes.
How a generator-style workflow blocks indefinitely on a ctx.promise() and resumes the moment an external HTTP handler calls resonate.promises.resolve.
Block a workflow on a human click without polling, schedulers, or queues. The workflow yields a durable promise that an HTTP gateway resolves from outside on a later request.
How a self-calling calculator function distributes its sub-tasks across task groups while keeping each step a durable checkpoint.
Parse an arithmetic expression into a tree, then recursively dispatch each sub-expression to a worker pool and the operator to a separate pool. Every sub-expression is its own durable promise, so partial results survive crashes and the recursion is plain Python.
How a Server Action and a status route share a durable promise id so the page can poll for completion without holding the request open.
A Next.js Server Action kicks off a 4-step background workflow keyed by a report id; a separate API route resolves the same id to poll for completion. The workflow and the status route share one in-process Resonate registry.
How a 15-line generator workflow produces mutual exclusion across workers without signals, lock workflows, or external coordination.
Serialize N workers around a shared resource without a lock workflow or signal channel. A generator that yields each worker in a for-loop IS the mutex; the SDK handles crash recovery and retry.
How a two-step money-transfer saga is exposed over HTTP with two layers of idempotency and crash-recoverable replay.
Move funds between two accounts as a debit + credit saga, triggered by an Express POST and made durable by Resonate. Idempotency is enforced at the execution id and at the ledger row.
How a single recursive function plus durable-promise IDs gives you distributed computation and a permanent result cache in one shape.
Compute factorial(n) by having one function call itself across a worker group. Each call pairs with a durable promise keyed by n, so previously computed results return without recomputing.
How three sequential LLM agents become four lines of generator code when every yield is a Resonate checkpoint.
Coordinate researcher, writer, and reviewer agents in sequence. Each agent handoff is a durable checkpoint, so a failure mid-pipeline retries only the failed agent — completed agents are not re-run.
We value your privacy
We use strictly necessary cookies to run this site. With your consent we also use Google Analytics to understand traffic. We do not load analytics until you choose to allow it. Privacy Policy.