A blue workflow diagram shows layered data branching through processes, a performance gauge, and automated computer systems.
Azure Durable Task Scheduler now has a public preview of task queues. They let you pace how fast work reaches your workers, and you can do it without creating a new task hub for each rate budget. Microsoft's Azure Update marks the feature "In preview." Task queues group orchestration and activity work within a task hub and optionally control the rate at which the scheduler delivers that work to workers. The update itself is mostly boilerplate. The Microsoft Learn documentation has the details that matter, and they are summarized below.

A blue workflow diagram shows layered data branching through processes, a performance gauge, and automated computer systems. What task queues are​

Durable Task Scheduler is Microsoft's managed backend for durable execution. It serves Durable Functions and the Durable Task SDKs. A task hub is the logical container for orchestration state. Until now, the main way to separate workloads was to create more task hubs. Microsoft's own docs note that task hubs on one scheduler share resources, so a heavily loaded hub can affect the others.

A task queue is a child resource of a single task hub. It is not a separate scheduler, and it has no compute of its own. Its optional setting is properties.throughput.actionsPerSecond. This setting limits the sustained rate of "work-item handouts", meaning deliveries from the scheduler to workers.

Typical use is a batch workflow that calls a rate-limited downstream service. You pace the work in the scheduler rather than hand-building throttles everywhere.

What the rate limit counts​

The unit is easy to misread, so here is what Microsoft counts:

  • Orchestration and activity work in the same queue share the configured rate.
  • Each orchestration turn delivered to a worker is one handout. An orchestration can take several turns.
  • Each activity delivery is one handout, and redeliveries count too.
  • Activities and sub-orchestrations inherit the parent's queue unless you override them with their own tag.
  • Entity work items don't use task queues.

Setting actionsPerSecond to 20 therefore means a sustained 20 handouts per second. It does not mean 20 completed orchestrations, 20 finished activities, or 20 downstream API calls per second. Short bursts can exceed the sustained rate. Real throughput can also be lower because of worker capacity, scheduler capacity, or work distribution.

What queues do not do​

Queues don't reserve compute, provide physical isolation, or set priority between named queues. If you omit throughput, the queue has no queue-specific limit. Scheduler and worker capacity limits still apply.

For strict downstream request limits, Microsoft says to also apply rate limiting where your activity calls the downstream service. In practice, treat this as a dispatch-pacing tool and not as an API quota.

Creating and managing a queue​

Task queues need management API version 2026-07-01-preview or later. Before you start, you need:

  • An existing scheduler and task hub.
  • Permission to manage resources under the task hub, such as Contributor. Data-plane roles alone aren't enough.
  • An SDK that supports the tags (see the support table below).
  • Workers that connect without work-item filters.

Queue names must be 3 to 64 letters, numbers, or hyphens. A queue has no location or Azure resource tags of its own. actionsPerSecond must be a positive integer, or you leave it out.

Microsoft documents three ways to create a queue:

  1. Azure CLI az rest: PUT to the queue resource URL with a body like {"properties":{"throughput":{"actionsPerSecond":20}}}.
  2. Direct ARM REST: the same PUT with a bearer token.
  3. Bicep: a resource of type Microsoft.DurableTask/schedulers/taskHubs/taskQueues@2026-07-01-preview. Some Bicep versions may show warning BCP081 because type definitions for the preview resource are missing. Microsoft says the warning doesn't block compilation or deployment.

The Azure CLI reference also lists an az durabletask taskqueue command group with create, delete, list, show, update and wait commands. It is an extension. That sits alongside the az rest route in the main guide, which says no dedicated CLI extension is required. Check your installed extension version before relying on either.

Wait for provisioning​

Management operations are asynchronous. After creating or updating a queue, poll properties.provisioningState until it reads Succeeded. Only then send tagged work. Stop if the state is Failed, an error occurs, or your polling timeout expires. An accepted request alone doesn't mean the queue is ready.

Updating and deleting​

  • PATCH with a new actionsPerSecond changes the rate. The docs show 10 as an example.
  • To remove the limit but keep the queue, PATCH with throughput set to null. If you leave throughput out of a PATCH, the rate stays unchanged.
  • PUT replaces the whole configuration. Leaving throughput out of a PUT removes the queue-specific limit.
  • Deleting is asynchronous. Poll until the queue returns 404 Not Found. Don't treat authorization errors as confirmation of deletion.
  • Deleting doesn't terminate orchestrations that used the queue. Don't use deletion to pause a workload, because tagged work then falls back to ordinary task-hub routing.

Routing work with DTS_TaskQueue​

You select a queue by setting the literal tag key DTS_TaskQueue to the queue name. You set it when you start an orchestration or schedule an activity. It is an orchestration/activity tag, not an Azure resource tag. It doesn't create the queue, and the queue must be in the same task hub.

You can split a workflow. For example, keep coordination in an orders queue and send a partner-API activity through a separate partner-api queue. The activity override doesn't move the parent orchestration.

The worker filter trap​

This is the requirement most likely to cause trouble. Only worker connections without work-item filters can receive work from defined queues. Any filter, including a wildcard, makes the connection ineligible. Unfiltered workers must also register every orchestration and activity routed to the queues.

The .NET Durable Task SDK generates filters from its task registry automatically. Microsoft's example opts out by calling .UseWorkItemFilters(null) when configuring the worker. In the Java, Python and Go SDKs, the guidance is not to opt in to filtering, and to remove any filter configuration you already have.

Two failure modes pull in opposite directions:

  • Queue exists, no eligible worker: the work waits. It does not fall back to a filtered worker.
  • Queue missing or deleted: work uses ordinary task-hub routing, and the rate limit is not enforced. Work runs unthrottled without any error.

The second case is the dangerous one. Create the queue, confirm Succeeded, then schedule tagged work.

SDK coverage​

Explicit DTS_TaskQueue tag support varies:

SDK or extensionStart orchestrationSchedule activitySchedule sub-orchestration
Durable Task .NET SDKYesYesYes
Durable Task JavaScript/TypeScript SDKYesYesYes
Durable Task Python SDKYesYesNo
Durable Task Java SDK (v1.6.0+)YesNoNo
Durable Task Go SDK (beta)YesYesYes
Durable Functions: .NET isolatedYesYesYes
Durable Functions: JavaYesNoNo

The Durable Functions .NET in-process, JavaScript and Python bindings don't expose these explicit tag options. Microsoft warns against assuming that a language's standalone SDK support carries over to its Durable Functions binding. Where explicit tags aren't available, sub-orchestrations and activities inherit the parent's queue.

Troubleshooting checklist​

If queued work isn't moving, check these in order:

  1. The queue exists and its provisioning state is Succeeded.
  2. The DTS_TaskQueue tag names the intended queue in the same task hub.
  3. A healthy worker is connected with no filters, and it registers the routed task types.

If work runs without the expected limit, suspect a missing or deleted queue. Also remember that handouts are not completed workflows, and that short bursts are allowed. Microsoft suggests using the scheduler dashboard to inspect orchestration status and tags.

Should you try it?​

The preview is for non-production use and testing. The feature fits teams that already share a task hub and want per-workload pacing without more hubs. The costs are the unfiltered-worker requirement and uneven SDK coverage. Teams that rely on work-item filters will have to change their worker setup first.

My take, based on general engineering experience and not on Microsoft's text: validate the "missing queue means no limit" behavior in a test environment, and add your own limiter in front of any API with hard quotas. Microsoft's guidance supports that approach.

 

References

  1. (In preview) Public Preview: Task Queues for Azure Functions durable task scheduler Azure Updates 2026-11-17T20:00:32Z
  2. Use task queues in Durable Task Scheduler (preview) - Durable Task | Microsoft Learn learn.microsoft.com
  3. Durable Task Scheduler - Durable Task | Microsoft Learn learn.microsoft.com