AWS Builder Center

Amazon EKS Provisioned Control Plane: HPA Sync Concurrency Increased Up to 40x

A closer look at how this update works under the hood, plus how to verify the effect on your own cluster and get the most out of it. Written for infrastructure and platform engineers running large-scale EKS clusters.

Introduction

On July 28, 2026, AWS announced an update to Amazon EKS Provisioned Control Plane that speeds up Pod autoscaling. The sync concurrency of the Horizontal Pod Autoscaler (HPA) has been significantly increased from the Kubernetes default, and it's applied automatically to any cluster using Provisioned Control Plane, with no configuration changes required.
If you operate large EKS clusters, you may have run into a familiar problem: with hundreds or thousands of HPA objects in a cluster, Pod scale-out can't keep up during a traffic spike, leading to increased latency or dropped requests. This update addresses that problem directly.
This post is for infrastructure and platform engineers who run large-scale EKS clusters, especially those evaluating or already operating Provisioned Control Plane. We'll dig into what changed and how it works under the hood.



What Changed

This update changes an internal Kubernetes control plane setting used by EKS Provisioned Control Plane. The number of HPA objects the HPA controller can process concurrently — HPA sync concurrency — has been substantially increased from the Kubernetes default of 5, with the exact value depending on the Control Plane Scaling Tier you've selected.
Item
Before
After
HPA sync concurrency
Kubernetes default (5)
Up to 40x, depending on tier (fixed per tier)
Scaling responsiveness in large clusters
Delays grow as the number of HPA objects increases
More HPA objects evaluated in parallel, reducing delay
Action required
―
None (applied automatically to Provisioned Control Plane clusters)
The "up to 40x" figure isn't a single, uniform value — it's a fixed number assigned to each Control Plane Scaling Tier (XL, 2XL, 4XL, and 8XL).

The Underlying Problem

The HPA controller evaluates HPA objects in parallel, up to the number specified by the kube-controller-manager's  --concurrent-horizontal-pod-autoscaler-syncs  flag. When the number of HPA objects in a cluster exceeds this value, some objects can't be processed within a single reconciliation cycle, which effectively lengthens the scaling interval. With a few dozen HPA objects, this delay is barely noticeable. But as clusters adopt microservices architectures and configure HPAs per service or namespace, the delay becomes significant.



How It Works

The Kubernetes HPA controller places every HPA object into a single work queue, and a number of workers — set by the  --concurrent-horizontal-pod-autoscaler-syncs  flag — process that queue in parallel. The more workers you have, the more HPA objects get processed per reconciliation cycle, which shrinks the queue backlog and reduces the delay between a change in load and the resulting scaling decision.

On EKS Provisioned Control Plane, this worker count (HPA sync concurrency) is pre-configured based on the Control Plane Scaling Tier you select:
Provisioned Control Plane Scaling Tier
HPA Sync Concurrency
vs. Kubernetes Default
XL
50
10x
2XL
100
20x
4XL
200
40x
8XL
200
40x
Since the upstream Kubernetes default is 5, even the smallest XL tier gets a 10x increase, while the 4XL and 8XL tiers reach 40x. The "up to 40x" figure in the announcement refers to these top two tiers.

Clusters That Benefit Most — and Least

Whether this improvement makes a difference depends on how many HPA objects your cluster runs. If the worker count already exceeds your HPA object count, the queue never backs up in the first place, so raising concurrency further won't produce a noticeable difference. On the other hand, clusters that configure HPAs per service or namespace as part of a microservices architecture tend to see queue backlog build up — and for these clusters, higher sync concurrency translates directly into faster scaling responses.
That said, even with higher concurrency, if the metrics source the HPA relies on — Metrics Server or a custom metrics adapter — responds slowly, that becomes the new bottleneck and limits the benefit.



Getting the Most Out of This Update

While the increase in HPA sync concurrency is applied automatically, how much benefit you actually see depends on your cluster's state and the configuration of surrounding components. Here's how to check whether it's working, and how to tune things further.

Checking the Effect

First, you can check which Control Plane Scaling Tier your cluster is running on with:
aws eks describe-cluster --name <cluster-name>

To see whether the HPA controller is keeping up, watch the  workqueue_depth{name="horizontalpodautoscaler"}  metric, available via Prometheus or CloudWatch. This metric reports the number of HPA objects waiting to be processed by the HPA controller. With sufficient concurrency, it should stay near zero and stable. If it stays persistently high, that's a signal you may want to consider moving to a higher scaling tier.
You can also check this from the Amazon EKS console: from your cluster's overview page, choose Monitor cluster to open the observability dashboard, then select the Control plane monitoring tab to view utilization under Control plane scaling.

Tuning Tips

To eliminate the metrics-source bottleneck, make sure you're running enough Metrics Server (or custom metrics adapter) replicas to handle your request volume, and keep metric queries efficiently scoped — this is a prerequisite for getting the full benefit of higher HPA sync concurrency.
Kubernetes HPA also supports a  behavior  field that lets you configure scale-up and scale-down policies and stabilization windows. Higher sync concurrency speeds up the scaling decision itself, but for workloads with volatile load patterns, it's worth revisiting your  behavior  settings too, to prevent excessive scaling oscillation (flapping).



Use Cases

This update delivers the most value in two scenarios AWS lists as use cases for Provisioned Control Plane: anticipated high-demand events and massively scalable workloads.
For scenarios with a predictable traffic surge — e-commerce sales, product launches, or major sporting and entertainment events — it's common for multiple microservices to each run their own independent HPA. When an event starts, many HPAs need to make scaling decisions at once, so higher HPA sync concurrency translates directly into a faster response.
The same applies to AI training/inference platforms and large-scale data processing platforms that run many nodes and many workloads. These clusters often run separate HPAs per workload type, which naturally means more HPA objects overall. This update reduces the delay in scaling decisions during load changes, cutting down on wasted cost and performance degradation from over- or under-provisioned resources.
Given that the whole reason organizations adopt Provisioned Control Plane is "large-scale, predictable performance," this HPA speedup reinforces that same direction. It's less a standalone new feature and more a reinforcement of the use cases Provisioned Control Plane already targets.



Summary

This update raises the HPA sync concurrency that EKS Provisioned Control Plane maintains internally, from the Kubernetes default, based on the Scaling Tier you've selected. No configuration change is required, and the more HPA objects your cluster runs — typically in the hundreds or thousands — the more noticeable the improvement in scaling responsiveness.
It might look like a minor technical change, but it reinforces the core value proposition of Provisioned Control Plane: predictable, high performance. Faster response to traffic spikes translates directly into a better user experience, and reducing the need for over-provisioned resources helps optimize cost. If you're already running Provisioned Control Plane, start by checking your cluster's  workqueue_depth  metric, and consider revisiting your Metrics Server configuration if needed.



References

Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article