AWS Lambda durable execution for .NET: long-running C# workflows without Step Functions (2026)

Summary. On 23 July 2026 AWS made the Lambda durable execution SDK for .NET generally available, so C# developers can now write multi-step workflows that checkpoint progress automatically and pause for up to a year while waiting on an external event. It is the third language SDK for Lambda durable functions, which AWS first announced in December 2025 and brought to Java in April 2026. The pitch is direct: keep the orchestration in your handler code instead of moving it into an AWS Step Functions state machine. That matters for cost and for developer experience. Step Functions Standard Workflows bill $0.025 per 1,000 state transitions, roughly $25 per million after the first 4,000 free transitions each month, and every branch and retry is a transition. Durable functions reuse the Lambda pricing you already pay and do not bill on-demand functions for wall-clock time while a workflow is paused. This guide covers what shipped, the four durable operations in the .NET SDK, the replay model that makes it work, a concrete cost and fit comparison against Step Functions, and the discipline your team needs before adopting it.

What AWS actually shipped on 23 July 2026

The general-availability release is a NuGet package, Amazon.Lambda.DurableExecution, that installs into the .NET toolchain you use today. There is a companion Amazon.Lambda.DurableExecution.Testing package with a local emulator, so you can build and debug a durable workflow on your laptop before it reaches an AWS Region. This is a real developer-experience gap that Step Functions has always had: a state machine is awkward to run and step through locally.

Durable functions extend Lambda's normal event-driven model with operations that record their results as checkpoints. When something interrupts the function, a timeout, a deployment, a wait on a human approval, the workflow resumes from the last checkpoint rather than starting the business process over. AWS describes the target workloads plainly: payment processing pipelines, AI agent orchestration, and human-in-the-loop approvals. Those share one trait: they run longer than a single Lambda invocation comfortably allows, and losing progress midway is expensive.

The feature itself is not new in August 2026, only the idiomatic C# surface is. Here is the short timeline, which matters if you are judging maturity:

So the underlying service has been generally available since spring 2026 and is deployed across a wide Region footprint. The .NET SDK is the newest wrapper on a runtime that has had months of production exposure through Java.

The four durable operations in the .NET SDK

The SDK gives C# code four building blocks. Each one is the unit that gets checkpointed, so the way you compose them is the way your workflow survives interruptions. The developer guide names them as steps, waits, callbacks, and durable invocation.

A first durable handler in C# looks like ordinary code with the durable operations marking the checkpoints. The shape below is illustrative of the SDK model described in the AWS developer guide, not a copy of a specific sample:

            public async Task<OrderResult> Handle(OrderRequest order, IDurableContext ctx)
{
    // Each step result is checkpointed, so a replay skips re-charging the card.
    var payment = await ctx.Step("charge-card",
        () => _payments.ChargeAsync(order.CardToken, order.Amount));

    // Suspend without paying for idle compute while we wait.
    await ctx.Wait("settlement-delay", TimeSpan.FromHours(2));

    // Pause until a human approves; can stay parked for up to a year.
    var approval = await ctx.Callback<Approval>("manager-approval");

    if (approval.Approved)
    {
        await ctx.Step("fulfil", () => _fulfilment.ShipAsync(order.Id));
    }

    return new OrderResult(order.Id, approval.Approved, payment.TransactionId);
}
          

The callback is the operation that changes the economics. A workflow parked on manager-approval is not running. AWS states that on-demand functions are not billed for duration while paused, so a payment that waits two days for a manager to click approve costs nothing in Lambda duration during that window. You still pay for the checkpoint data that persists the paused state, which is the trade covered below.

How replay works, and why determinism is now your problem

The mechanism behind durable functions is checkpoint plus replay. When a workflow resumes, the SDK runs your handler from the top again, but it does not re-execute completed operations. Instead it feeds the stored checkpoint result back in and moves on to the first operation that has not finished. That is how a function that "paused for a year" picks up exactly where it left off.

Replay has a sharp edge that every team must understand before shipping. Because your code runs from the beginning on every resume, any code outside a durable operation has to be deterministic. If you generate a UUID, read DateTime.UtcNow, or draw a random number in the body of the handler rather than inside a step, the value will differ on replay and the workflow can diverge from its recorded history. The AWS best-practices guidance is explicit that non-deterministic work must be wrapped in a step so the value is captured once and replayed thereafter.

In practice that means a rule your reviewers have to enforce:

            // Wrong: a new GUID and timestamp are produced on every replay.
var id = Guid.NewGuid();
var now = DateTime.UtcNow;

// Right: capture once inside a step; replay returns the stored value.
var id = await ctx.Step("gen-id", () => Guid.NewGuid());
var now = await ctx.Step("stamp-time", () => DateTime.UtcNow);
          

This is the single largest adoption risk. Durable functions impose a coding contract on the whole team. A group that cannot hold replay-safe discipline across every contributor will ship determinism bugs that only surface on an interruption, which is the worst time to find them. It is a training and code-review problem as much as a coding one.

Durable functions versus Step Functions: a real comparison

The honest framing is not "durable functions replace Step Functions." It is "durable functions remove the reason many teams reached for Step Functions in the first place." Here is the side-by-side on the vectors that actually drive the decision.

Two rows deserve unpacking. On cost, Step Functions Standard meters every state transition, so a workflow with many branches, retries, and parallel legs multiplies transitions quickly, and the bill grows with them. Durable functions have no per-transition meter; the cost is Lambda compute plus the storage of checkpoint data, including the invocation event, payloads returned from steps, and data passed when completing callbacks.

On fit, Step Functions is still the better tool for orchestration that spans many AWS services with a visual graph, or for workflows with thousands of states where a deep replay chain would be inefficient. Durable functions are the better tool for logic that lives in your application code, that a developer would rather express in C# than in a JSON state machine, and that needs long waits without paying for idle compute. If Step Functions has always felt like an awkward fit for a particular workflow, that workflow is the candidate to move. If Step Functions already serves a workflow well, the migration cost rarely justifies the change.

A migration and adoption checklist

If you are a .NET shop weighing this, the sequence below keeps the risk contained.

1. Pick one new workflow, not a working Step Functions machine, for the first build. New long-running workflows are where durable functions shine and where you carry no migration cost.

1. Add a lint or review rule that bans Guid.NewGuid(), DateTime reads, and randomness outside a step. Make it a blocking check, not a guideline.

1. Use the local testing emulator from the Amazon.Lambda.DurableExecution.Testing package in continuous integration so replay behaviour is exercised before deployment.

1. Model human and agent approvals as callbacks, and confirm your idle economics by parking a workflow and watching the duration bill stay flat.

1. Instrument checkpoint data volume. It is a storage and retention cost that grows with payload size, so keep step results small and store large blobs in Amazon S3 with a reference in the checkpoint.

1. Only after two or three workflows run cleanly should you consider moving an existing Step Functions workflow, and only if its transition costs or code-versus-config friction justify the work.

For teams already orchestrating agents, the same discipline applies. AI agent orchestration is one of the three headline use cases AWS names, and a durable callback is a natural fit for a human reviewing an agent's proposed action before it executes. Teams building in that direction should read our guide to running enterprise AI agents in production alongside this one, because the failure modes overlap.

India-specific considerations

For teams building from India, durable functions are available in the AWS Asia Pacific (Mumbai) Region as part of the wide Region expansion completed in April 2026, so you can keep both compute and checkpoint data in-country. That matters under the Digital Personal Data Protection Act 2023 (DPDP Act), where a payment or approval workflow will often carry personal data through its steps and callbacks. Keeping checkpoint storage in the Mumbai Region, and keeping step payloads minimal, reduces the amount of personal data sitting in a paused workflow's persisted state.

On cost, the pricing is set in US dollars and billed to your AWS account regardless of location. A Step Functions Standard workload running a million state transitions is about $25; at an approximate ₹85 to the dollar that is roughly ₹2,100, and the figure scales linearly with branching. A durable-functions equivalent shifts that spend into Lambda compute plus checkpoint storage, which is usually lower for long-waiting workflows but has to be measured for your own payload sizes. Indian engineering teams weighing serverless orchestration should also read our Bun versus Node.js backend runtime decision for the parallel runtime-cost logic, and our note on C# union types and the .NET 11 migration if you are modernising the language surface at the same time. For the wider platform picture, our web platform developer guide for 2026 sets the context.

The bottom line for .NET teams

The real cost of this feature is not the code, it is the replay-safety discipline. If your team can hold that contract, durable functions remove a whole class of orchestration plumbing and a per-transition bill for the workflows that fit. If it cannot, Step Functions' configuration-first model contains the blast radius better. Start with one new workflow, enforce the determinism rule in review, and measure the checkpoint-storage cost against the Step Functions transitions you would have paid. The decision is workload by workload, not all or nothing.

FAQ

How eCorpIT can help

eCorpIT builds and modernises serverless workflows for .NET and JVM teams, and durable execution is exactly the kind of orchestration shift where the design decisions made early determine the running cost later. Our senior engineering teams can assess whether a given workflow belongs in durable functions or Step Functions, put the replay-safety guardrails into your code review, and measure the real checkpoint-storage cost against your current bill. If you are planning a serverless build or an API integration and modernization programme, talk to us at /contact-us/.

References

1. AWS Lambda durable execution SDK for .NET is now generally available — AWS What's New, 23 July 2026.

1. Preserve progress despite interruptions: AWS Lambda durable functions — AWS product page.

1. Durable execution SDK — AWS Lambda Developer Guide.

1. Lambda durable functions developer guide — AWS Lambda Developer Guide.

1. Determinism during replay — AWS Durable Execution SDK Developer Guide.

1. Best practices for Lambda durable functions — AWS Lambda Developer Guide.

1. AWS Lambda pricing — AWS.

1. AWS Step Functions pricing — AWS.

1. AWS Lambda announces durable functions for multi-step applications and AI workflows — AWS What's New, December 2025.

1. AWS Lambda Durable Execution SDK for Java GA — AWS What's New, April 2026.

1. AWS Lambda durable functions are now available in 16 additional AWS Regions — AWS What's New, April 2026.

1. Amazon.Lambda.DurableExecution on NuGet — NuGet package.

1. AWS Weekly Roundup, 27 July 2026 — AWS News Blog.

_Last updated: 1 August 2026._