A cartoon gopher works at a laptop displaying an automated workflow, with cloud scheduling and server diagrams above.
Go developers who want durable workflows on Azure now have a first-party option in public preview. Microsoft's Azure Updates entry for the Durable Task SDK for Go went up on November 17, 2026. It is labelled "In preview," and Azure defines that tier as available to all Azure customers for non-production use and testing. This is not a production release. Even the SDK's GitHub repository says "This SDK is currently in beta."

The Azure Updates entry itself says very little. The substance comes from Microsoft's Ignite 2026 Azure Functions and Durable Task Scheduler post and from the SDK documentation. This article is based on those, plus the SDK repository's own description.

A cartoon gopher works at a laptop displaying an automated workflow, with cloud scheduling and server diagrams above. What the SDK actually is​

The Durable Task SDK for Go is an open-source library for writing orchestrations, activities and durable entities as ordinary Go functions. Microsoft's docs say you host the application on your own compute. That could be containers, Kubernetes or VMs. Durable Task Scheduler (DTS) stores the execution history and dispatches work to your Go workers.

The pitch is the same one the Durable Task family makes in other languages. Multi-step workflows should survive process restarts and infrastructure failures. Long waits, such as human approvals, webhooks or timers, shouldn't tie up compute. Parallel work should fan out and aggregate reliably. Microsoft's overview lists these as the reasons to use the SDKs, and it says they run without being locked to Azure Functions.

The Ignite announcement lists the preview's headline features as code-first orchestrations, activities, fan-out/fan-in, external events, durable timers and retry policies on Go 1.25+. The documentation goes further. It also covers sub-orchestrations, continue-as-new, suspend/resume and durable entities.

Requirements and install​

  • Go version: Go 1.25 or later.
  • Install command: go get github.com/microsoft/[email][email protected][/email]. Run go mod tidy after adding imports.
  • Local development: Docker or a compatible container runtime, to run the Durable Task Scheduler emulator.
  • Azure: an existing scheduler and task hub, plus an identity with the Durable Task Data Contributor role.

One module contains the task, api, client, and durabletaskscheduler packages. In practice:

  • task holds the orchestration, activity and entity contexts.
  • durabletaskscheduler handles connection options and the client and worker connections.
  • client covers worker configuration such as concurrency, versioning and work-item filters.
  • api covers instance IDs and management options.

Programming model essentials​

Orchestrators have the signature func(*task.OrchestrationContext) (any, error). Activities take a task.ActivityContext. You register both by stable name in a task registry, and the names must match what your activity calls and client scheduling use. Microsoft recommends client.WithAutoWorkItemFilters() so a worker doesn't consume tasks that only another application registered.

The usual orchestrator rules apply, and they trip people up:

  • Don't do network calls, file I/O or environment reads inside an orchestrator. Put that work in activities.
  • Use the SDK's durable primitives rather than goroutines, channels, sync.WaitGroup or time.Sleep.
  • Use ctx.Logger() for replay-aware logging.
  • Activities can run more than once, so make external side effects idempotent.

One gotcha is easy to miss. WaitForOrchestrationCompletion returning without an error only means the instance reached a terminal state. It doesn't mean the workflow succeeded. Fetch payloads, check that RuntimeStatus is completed, then decode the output. For failures, read FailureDetails.

Connecting: emulator versus Azure​

For local work, the documented connection string is Endpoint=http://localhost:8080;TaskHub=default;Authentication=None. That is for the emulator only. For Azure, use your scheduler's HTTPS endpoint and task hub name. Choose Authentication=DefaultAzure or Authentication=AzureCLI. Managed identity and workload identity are also supported.

The quickstart reads DTS_CONNECTION_STRING and passes it to NewOptionsFromConnectionString. The SDK doesn't read that variable on its own, so you have to wire it up yourself.

What the beta does not do​

This is the part to read before you plan a migration.

  • It isn't a drop-in upgrade from v0.6.0. It connects to Durable Task Scheduler or the local emulator, not the embedded SQLite or PostgreSQL backends in earlier Go SDK versions. The standalone gRPC host is gone too. The older module also carried a warning that it should not be used for production workloads.
  • There is no bundled storage backend. Orchestrations only run against DTS or its emulator. Unit-test activities and business logic with ordinary Go tests. Verify orchestration and replay behaviour with integration tests against the emulator or a dedicated task hub.
  • Schedules aren't portable. Go schedules don't share their persisted state format with other SDKs. Use a Go-only task hub.
  • Entity locks differ. Go and Python order multi-entity locks differently from .NET. Don't acquire overlapping lock sets concurrently across those runtimes.
  • Rewind is conservative. The Go worker rejects some histories. An accepted rewind request doesn't prove recovery. Check for a new execution ID and a successful output.
  • Emulator management has limits. Instance listing and filtered purge are affected. Clean up per instance and don't clear a shared hub.
  • History export is itself preview. It copies terminal orchestration histories to Azure Blob Storage. Use an isolated, Go-only task hub and export destination so export jobs can't touch unrelated data.

Go and Azure Functions​

Don't read this as "Go joins Durable Functions." Microsoft's SDK documentation says plainly that Go isn't a Durable Functions language. Separately, Microsoft's Ignite post says Go support on Azure Functions Flex Consumption is now generally available on Go 1.24+. It also says the new SDK powers middleware/durabletask in the Azure Functions Go worker. Those two statements sit side by side in Microsoft's materials. So there is a Durable Task path for Go inside Functions, but the Durable Functions language list is a separate matter.

How it compares to the other SDKs​

Microsoft's overview table shows the .NET, Python and Java SDKs as GA. JavaScript/TypeScript is in preview and Go is in beta. The feature checklist covers orchestrations, activities, sub-orchestrations, timers, external events, entities, retries, continue-as-new and suspend/resume. Go ticks every box. Its maturity label is the one that lags. Cross-language caveats like schedules and entity lock ordering matter if you mix runtimes in one task hub.

Bottom line​

Teams running Go services, whether on Kubernetes, VMs or containers, can now prototype durable workflows against a managed scheduler instead of building their own state machine. The caveats are real:

  • It's preview, so Microsoft says not to use it for production.
  • It needs DTS or the emulator.
  • Anyone on the older SQLite/PostgreSQL-backed Go module will need a rewrite-level migration, not a version bump.

Run the emulator, build a small fan-out/fan-in sample, and test replay behaviour before you commit.

Everything above reflects Microsoft's documentation and announcements as of this writing. I haven't tested the SDK myself.

 

References

  1. (In preview) Public Preview: Durable Task SDK for Go Azure Updates 2026-11-17T20:00:32Z
  2. durable-task-overview.md github.com
  3. durable-task-go.md github.com