Amazon Web Services announced on November 19, 2026 that its open source Durable Execution SDK for Rust has reached general availability. Rust teams can now write Lambda durable functions in their own language, with the service saving progress as each step finishes and pausing a workflow for as long as a year while it waits on outside events.
The release matters because Rust was a natural fit for Lambda's speed and memory profile but lacked a supported way to build multi-step orchestrations there. With a production-ready crate, approval flows, deployment rollouts and AI pipelines that wait for a human can live in one async Rust function rather than in hand-written state tracking.
What AWS announced
The SDK is published on crates.io as aws-durable-execution-sdk, with its source on GitHub under the aws organization. It targets Lambda durable functions, the feature that lets a function record checkpoints and resume after a timer, a callback or a timeout instead of starting over.
AWS lists several typical uses for it:
- Infrastructure automation that runs across many minutes or days.
- Staged deployment rollouts that stop at an approval gate.
- AI pipelines that pause after a model call until a person checks the output.
- Agent-in-the-loop flows where another system sends the signal to continue.
How the Rust SDK works
A durable handler is an ordinary async function that takes an event plus a DurableContext and returns a Result. Each durable operation is a normal Rust future, so code simply awaits it, and independent operations can run at the same time.
The context offers a set of building blocks:
- Steps that store their result, so a replay returns the saved value rather than running the body again.
- Waits that suspend the execution on a timer.
- Callbacks that hold the workflow until an external system or person answers.
- Invocations of other durable functions.
- Map and parallel operations that fan work out and return results in input order, with a fail-fast default that can be relaxed.
- Retry strategies, where a step with no explicit setting gets a default preset of six attempts.
Under the hood, an invocation stops as soon as the handler has to suspend. The service later calls the function again, and the SDK replays recorded results until it reaches new work. Logging goes through the tracing crate, with a filter that hides records produced during replay.
Build, test and deploy
The SDK needs Rust 1.94.1 or newer. Developers add the crate with cargo, compile with Cargo Lambda and ship a single bootstrap binary on the provided.al2023 runtime, on either x86-64 or Arm64 Graviton.
The docs warn against a plain cargo build. Because the provided.al2023 image carries glibc 2.34, a binary linked against a newer glibc crashes when it starts, while Cargo Lambda builds through Zig and pins a compatible glibc. SAM users can set the rust-cargolambda build method and add a durable configuration block to the function.
For testing, the crate includes a local runner behind a test-util feature. Whole workflows can be run with cargo test on a laptop or in CI, with no network access and no AWS credentials.
What it means for developers
The biggest operational detail is how failures surface. When a durable handler returns an error, the SDK wraps that failure in a Lambda reply that looks successful.
As a result, the usual Errors metric does not move, failure destinations and dead-letter queues are not used, and X-Ray does not flag the trace. Teams need alerts built on the status of each durable execution, or a broken workflow can slip by.
Determinism also matters. Operations get their IDs from the order in which the handler calls them, so code should take the same path on every replay. A panic behaves differently from a returned error: it fails the invocation and records nothing, and a panic that repeats on every attempt loops until the execution times out.
The function's IAM role must be able to write to CloudWatch Logs, and it also needs two durable permissions: lambda:CheckpointDurableExecution and lambda:GetDurableExecutionState. Results larger than about 6 MB are checkpointed as the execution result rather than returned in the response, which is worth knowing for data-heavy steps.
For readers following the wider feature, we covered how Lambda durable functions can now pause, resume and delete executions. On the language side, see our story on Rust 1.100 and Cargo dependency cooldowns.
How to get started
Start with the quickstart in the Rust guide, which builds a handler with two steps and a short wait. Install Cargo Lambda with a method that also brings in Zig, then deploy the sample with SAM and invoke it to watch the execution move from running to succeeded.
Before moving real work over, write local tests for the replay path and set up alarms on execution status. Regional availability and pricing follow the general Lambda durable functions pages.
Conclusion
General availability of the Rust Durable Execution SDK gives Rust developers a supported route to long-running, checkpointed workflows on Lambda. The async design feels natural in Rust, and the local test runner lowers the barrier to trying it. The main thing to plan for is monitoring, since failed executions do not trigger the usual Lambda error signals.
Sources
- AWS What's New: AWS Lambda Durable Execution SDK for Rust is now generally available
- AWS Durable Execution SDK Developer Guide: Rust SDK
- GitHub: AWS Durable Execution SDK for Rust
See my articles more often when you search Google.
