Upgrading Workflows
Workflows that block on external events for days, weeks, or months can outlive many deployments. The key is to identify a clean upgrade point in the workflow (a moment where it's safe to checkpoint state and start fresh) and then call start() with deploymentId: "latest" to spawn a new run carrying that state forward. The current run ends; the next run begins on whatever deployment is live at that moment, so shipped fixes apply immediately without ever migrating an in-flight run.
For the underlying model (why runs pin to a deployment by default, how cancel-and-rerun works, and how state crosses the version boundary), see Versioning. This recipe focuses on event-driven workflows that need to keep advancing across deployments.
A clean upgrade point is any spot in the workflow where:
- All in-progress side effects have completed or aren't needed by the next iteration.
- The relevant state can be serialized into the workflow's input arguments.
- The workflow can create a checkpoint after handling an external event, completing a batch, or finishing a logical phase.
There are two ways to apply this:
- Upgrade on every iteration (Method 1): Each run handles a single event and unconditionally hands off to a fresh run on the latest deployment before exiting. This method needs no extra triggers, but every event incurs the respawn cost.
- Upgrade on demand through a dedicated hook (Method 2): A single long-lived run handles many events in a loop and respawns only when an
upgradeHookfires. A separate endpoint resumes that hook from your control plane, for example, after a deployment. This method provides more control and fewer respawns at the cost of an explicit trigger.
When to use each
- Use Method 1 when iterations are short and frequent, the work is inexpensive to checkpoint, and you want shipped fixes to apply on the next event. Long-lived session workflows, such as subscriptions, queues, and finite-state machines (FSMs), that already process events one at a time fit this method.
- Use Method 2 when iterations are infrequent or expensive, or when you need to roll out a fix to a fleet of in-flight runs after a deployment by fanning out to a control-plane endpoint. This method also fits when an upgrade should be an explicit operation rather than a side effect of handling each event.
Method 1: Upgrade on every iteration
Each run inherits state via its argument, blocks on a hook, processes the resume, then unconditionally hands off to its successor by calling start() directly from the workflow body with deploymentId: "latest".
Resuming the hook
Any server-side code can resume the currently-active iteration by calling .resume() with the run ID:
The caller tracks the active runId, such as in a database or returned from the previous iteration, and updates it whenever the chain advances.
Method 2: Upgrade on demand via a dedicated hook
Use a single long-running workflow that handles events in a loop. Define a second hook, upgradeHook, alongside the work hook, and race them. While only the work hook fires, the run keeps handling events on its current deployment. When upgradeHook resumes, the workflow captures current state and respawns on the latest deployment, then exits.
Triggering the upgrade
Expose a separate endpoint that resumes upgradeHook for a given run. Call it from your deployment pipeline, an admin UI, or a fan-out script that iterates over every active run after shipping a fix.
To upgrade a fleet of runs after a deployment, list active runs from a tracking store and call this endpoint for each run.
How it works
deploymentId: "latest"is the upgrade knob. Without it, the spawn pins to the current deployment. With it, the new run resolves to whatever deployment is current when the runtime picks it up, so any shipped fix applies starting from that respawn. The respawned run runs at the spec version of the deployment it lands on. Both methods rely on this.start()runs directly from the workflow body. In v5,start()is step-backed, so it can be called from a workflow function and still records a deterministic step boundary in the event log, so no manual"use step"wrapper is required.- State carries through the function argument. The accumulating context flows from run N to run N+1 as a serialized argument. No external store is required for the state itself.
- Per-run hook tokens. Using
workflowRunIdas the hook token scopes each iteration's wait to its own run, so multiple chains can run concurrently without interfering. - Method 1 vs Method 2 is only where the spawn happens. In Method 1 every run spawns its successor unconditionally before exiting; there is no long-lived process to migrate. In Method 2 the spawn happens only when the upgrade hook fires; otherwise the loop keeps handling events on the same run.
Adapting to your use case
- Combine with a sleep: Race the hook against
sleep()so iterations also tick on a timer.Promise.race([hook, sleep("1d")])lets the workflow advance even if no external event arrives. - Use stateless successors: If the next iteration doesn't need the previous state, such as for a pure event router, call
start(longRunningQueue, [], { deploymentId: "latest" })and skip the argument plumbing. - Persist state externally: If state needs to be readable from outside the workflow for dashboards, debugging, or recovery, write it to a database in a step before spawning the next run.
- Track the active
runIdexternally: The system that resumes the hook needs to know the current run. Capture therunIdreturned bystart()and write it to a database keyed by a stable session identifier in a step, so resumers always look up the latest run.
Caveats
- Maintain backward compatibility: Because the next run executes on a different deployment, the workflow's input arguments and return type must remain compatible across deployments. Adding required fields, removing fields, or changing types can cause serialization failures. See the
deploymentId: "latest"callout. - Keep the workflow identity stable: The function name and file path form the workflow identity. Renaming the function or moving the file across a deployment changes the workflow ID, so the next iteration will fail to resolve.
- Account for the gap between iterations: The current run ends as soon as
start()returns, and the next run starts asynchronously. A resume that arrives in that window can fail with "hook not found." Make resumers retry, or have the API persist pending payloads and apply them once the next iteration is ready. - Track active Method 2 runs externally: Because Method 2's runs are long-lived, the set of in-flight runs changes only when one starts, completes, or upgrades. Persist run IDs and clean them up on completion or upgrade so a rollout script can fan out reliably. After resuming
upgradeHook, update the tracked run ID once the new run reports back, as you would in Method 1.
Key APIs
"use workflow": Marks the orchestrator function.start()withdeploymentId: "latest": Spawns the successor on the newest deployment.defineHook(): Suspends the workflow until an external event resumes it.getWorkflowMetadata(): ExposesworkflowRunIdfor per-run hook tokens.