Durable Execution SDK for .NET — Now Generally Available 🎉

[GarrettBeatty]

Durable Execution SDK for .NET — Now Generally Available 🎉

The AWS Lambda .NET team is excited to announce the general availibility of the AWS Lambda Durable Execution SDK for .NET (Amazon.Lambda.DurableExecution).

Durable Execution lets you build resilient, long-running Lambda functions that automatically checkpoint their progress and resume after failures. Workflows can run for up to one year, and you're only charged for active compute time — not for the time spent waiting.

https://aws.amazon.com/blogs/developer/aws-durable-execution-sdk-for-net-now-generally-available/

Why Durable Execution?

Today, orchestrating multi-step workflows in Lambda often means stitching together Step Functions state machines, SQS queues, or DynamoDB-backed state, and writing your own logic to track progress and recover from failures. Durable Execution lets you express that same workflow as ordinary C# code — await your steps, your waits, and your callbacks — while the SDK handles checkpointing, retries, and replay-safe resumption for you.

Key features

• Automatic checkpointing — progress is saved after each step; failures resume from the last checkpoint.
• Cost-effective waits — suspend execution for minutes, hours, or days without compute charges.
• Configurable retries — built-in retry strategies with exponential backoff and jitter.
• Replay safety — functions deterministically resume from checkpoints after interruptions.
• Type safety — full generic type support for step results.
• AOT-friendly — pluggable ILambdaSerializer for trimmed / Native AOT functions.

For example, a multi-step order workflow with a built-in wait becomes:

private async Task<OrderResult> Workflow(Order order, IDurableContext ctx)
{
    var reservation = await ctx.StepAsync(
        async (_, ct) => await InventoryService.ReserveAsync(order.Items, ct),
        name: "reserve-inventory");

    var payment = await ctx.StepAsync(
        async (_, ct) => await PaymentService.ChargeAsync(order.PaymentMethod, order.Total, ct),
        name: "process-payment");

    // Suspend for 2 hours with no compute charges, then resume.
    await ctx.WaitAsync(TimeSpan.FromHours(2), name: "warehouse-processing");

    var shipment = await ctx.StepAsync(
        async (_, ct) => await ShippingService.ShipAsync(reservation, order.Address, ct),
        name: "confirm-shipment");

    return new OrderResult(order.Id, shipment.TrackingNumber);
}

---

The package is available on nuget

📦 Amazon.Lambda.DurableExecution

dotnet add package Amazon.Lambda.DurableExecution

Deployment. Durable functions deploy as a plain zip package on the managed dotnet10 runtime — Both the executable programming model (a Main that builds a LambdaBootstrap) and the class-library programming model (a plain Handler method, the same model used by non-durable functions) are supported.

Deploying a durable function (zip on the managed runtime)

The end-to-end integration tests build, deploy, and invoke durable functions exactly this way. See DurableFunctionDeployment.cs for the full lifecycle (IAM role → dotnet publish → zip → CreateFunction → invoke), and the TestFunctions/ folder for runnable example functions (each paired with a test).

1. Project file — choose either programming model.

Executable model — build an executable named bootstrap:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net10.0</TargetFramework>
    <OutputType>Exe</OutputType>
    <AssemblyName>bootstrap</AssemblyName>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Amazon.Lambda.DurableExecution" Version="0.1.1-preview" />
    <PackageReference Include="Amazon.Lambda.RuntimeSupport" Version="*" />
    <PackageReference Include="Amazon.Lambda.Serialization.SystemTextJson" Version="*" />
  </ItemGroup>
</Project>

Class-library model — a normal Lambda class library (no OutputType, no RuntimeSupport reference); the managed runtime supplies the bootstrap loop:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net10.0</TargetFramework>
    <GenerateRuntimeConfigurationFiles>true</GenerateRuntimeConfigurationFiles>
    <AWSProjectType>Lambda</AWSProjectType>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Amazon.Lambda.DurableExecution" Version="0.1.1-preview" />
    <PackageReference Include="Amazon.Lambda.Serialization.SystemTextJson" Version="*" />
  </ItemGroup>
</Project>

2. Handler — the executable model wires up LambdaBootstrap in Main; the class-library model declares the serializer with an assembly attribute and exposes a plain Handler.

Executable model:

public class OrderProcessor
{
    public static async Task Main()
    {
        var handler = new OrderProcessor();
        var serializer = new DefaultLambdaJsonSerializer();
        using var wrapper = HandlerWrapper.GetHandlerWrapper<DurableExecutionInvocationInput, DurableExecutionInvocationOutput>(
            handler.Handler, serializer);
        using var bootstrap = new LambdaBootstrap(wrapper);
        await bootstrap.RunAsync();
    }

    public Task<DurableExecutionInvocationOutput> Handler(
        DurableExecutionInvocationInput input, ILambdaContext context)
        => DurableFunction.WrapAsync<Order, OrderResult>(Workflow, input, context);

    private async Task<OrderResult> Workflow(Order order, IDurableContext ctx) { /* ... */ }
}

Class-library model:

[assembly: LambdaSerializer(typeof(DefaultLambdaJsonSerializer))]

namespace OrderProcessor;

public class Function
{
    public Task<DurableExecutionInvocationOutput> Handler(
        DurableExecutionInvocationInput input, ILambdaContext context)
        => DurableFunction.WrapAsync<Order, OrderResult>(Workflow, input, context);

    private async Task<OrderResult> Workflow(Order order, IDurableContext ctx) { /* ... */ }
}

3. Publish and zip the package:

# Publish a framework-dependent Linux build (the dotnet:10 managed runtime supplies the runtime)
dotnet publish -c Release -r linux-x64 --self-contained false -o bin/publish

# Zip the publish output (no top-level folder)
cd bin/publish && zip -r ../function.zip . && cd -

4. Create the function as a zip package on the managed dotnet10 runtime, with a DurableConfig. The execution role needs both the basic execution policy and the durable execution policy:

• arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
• arn:aws:iam::aws:policy/service-role/AWSLambdaBasicDurableExecutionRolePolicy

await lambdaClient.CreateFunctionAsync(new CreateFunctionRequest
{
    FunctionName = "my-durable-fn",
    Runtime      = "dotnet10",
    // Executable model: "bootstrap".
    // Class-library model: an Assembly::Namespace.Type::Method string,
    //   e.g. "OrderProcessor::OrderProcessor.Function::Handler".
    Handler      = "bootstrap",
    Role         = roleArn,
    Code         = new FunctionCode { ZipFile = new MemoryStream(File.ReadAllBytes("bin/function.zip")) },
    Timeout      = 30,
    MemorySize   = 256,
    DurableConfig = new DurableConfig { ExecutionTimeout = 60 }
});

5. Invoke it with a DurableExecutionName, then track it via GetDurableExecution / GetDurableExecutionHistory:

await lambdaClient.InvokeAsync(new InvokeRequest
{
    FunctionName          = "my-durable-fn",
    Qualifier             = "$LATEST",
    Payload               = payload,
    DurableExecutionName  = $"order-{Guid.NewGuid():N}"
});

Core operations

Your handler delegates to DurableFunction.WrapAsync, which gives your workflow an IDurableContext — your interface to durable operations:

• Steps — execute code with automatic checkpointing, retry strategies, and at-least/at-most-once semantics.
• Wait — pause execution without compute charges.
• Wait For Condition — poll until a condition is met, suspending between polls.
• Callbacks — wait for external systems (approvals, webhooks) to respond.
• Child Contexts — group related operations into isolated, checkpointed units.

📖 Learn more in the Durable Execution SDK README, which includes a complete getting-started walkthrough and full examples of both the executable and class-library programming models.

Related SDKs

Durable Execution is available across multiple languages:

• aws-durable-execution-sdk-java — Java SDK
• aws-durable-execution-sdk-js — JavaScript / TypeScript SDK
• aws-durable-execution-sdk-python — Python SDK

---

We want your feedback 🙏

We cannot overstate how critical your feedback is. Please try it out and let us know what works, what doesn't, and what you'd like to see

[ParidelPooya]

🎉🎉🎉

[Lanayx]

Does it work with F#?

[normj]

@Lanayx There is nothing C# specific about the Durable function support and F# should have no problems. Will love to hear any feedback if you find issues. Here is my conversation of one of our C# test functions in to F#

open System
open System.Threading
open System.Threading.Tasks
open Amazon.Lambda.Core
open Amazon.Lambda.DurableExecution
open Amazon.Lambda.RuntimeSupport
open Amazon.Lambda.Serialization.SystemTextJson

type TestEvent() =
    member val OrderId : string = null with get, set

type TestResult() =
    member val Status : string = null with get, set
    member val Data : string = null with get, set

type Function() =

    member _.Handler(
        input: DurableExecutionInvocationInput,
        context: ILambdaContext
    ) : Task<DurableExecutionInvocationOutput> =
        DurableFunction.WrapAsync<TestEvent, TestResult>(
            Func<TestEvent, IDurableContext, Task<TestResult>>(fun input context ->
                Function.Workflow(input, context)),
            input,
            context)

    static member private Workflow(
        input: TestEvent,
        context: IDurableContext
    ) : Task<TestResult> =
        task {
            let! step1 =
                context.StepAsync<string>(
                    (fun (_: IStepContext) (_: CancellationToken) ->
                        task {
                            do! Task.CompletedTask
                            return $"validated-{input.OrderId}"
                        }),
                    name = "validate"
                )

            do!
                context.WaitAsync(
                    TimeSpan.FromSeconds(3.0),
                    name = "short_wait"
                )

            let! step2 =
                context.StepAsync<string>(
                    (fun (_: IStepContext) (_: CancellationToken) ->
                        task {
                            do! Task.CompletedTask
                            return $"processed-{step1}"
                        }),
                    name = "process"
                )

            return
                TestResult(
                    Status = "completed",
                    Data = step2
                )
        }

    static member Main(args: string[]) : Task =
        task {
            let handler = Function()
            let serializer = DefaultLambdaJsonSerializer()

            let handlerFunc =
                Func<DurableExecutionInvocationInput, ILambdaContext, Task<DurableExecutionInvocationOutput>>(
                    fun input context -> handler.Handler(input, context)
                )

            use handlerWrapper =
                HandlerWrapper.GetHandlerWrapper<DurableExecutionInvocationInput, DurableExecutionInvocationOutput>(
                    handlerFunc,
                    serializer
                )

            use bootstrap = new LambdaBootstrap(handlerWrapper)

            do! bootstrap.RunAsync()
        }

[<EntryPoint>]
let main args =
    (Function.Main(args)).GetAwaiter().GetResult()
    0

[GarrettBeatty]

A new version of lambda annotations was shipped as well to support durable executions.

Managed runtime support is also rolling out to some regions now (so the container workaround is no longer needed). I have updated the issue description with new deployment steps

[GarrettBeatty]

hi everyone we have published these latest preview versions

Amazon.Lambda.DurableExecution 0.3.2-preview - main sdk

Amazon.Lambda.DurableExecution.Testing 0.1.0-preview - testing package

which are looking to be our release candidates before going to version 1.0.

We encourage you to try out these latest versions! We will soon be planning on making these non-preview and updating to 1.0. Thank you

[vladimir-ilnytskyi]

@GarrettBeatty Could you please specify for which regions durable execution dotnet runtime is supported? Didn't yet check deployments via await lambdaClient.CreateFunctionAsync(new CreateFunctionRequest but seems like from AWS console in europe central 1 region enabling durable execution disables dotnet10.

[GarrettBeatty]

@vladimir-ilnytskyi on the AWS console side (the ui) the change is still rolling out in some regions (i can see internally it hasn't reached eu-central yet). However, you should be able to create it via lambdaClient.CreateFunctionAsync in the meantime.

[GarrettBeatty]

@vladimir-ilnytskyi looks like it got rolled out today. i see it in my account in eu-central-1 Frankfurt region