HPA, VPA, KEDA, and Karpenter work together by scaling different layers of a Kubernetes application: HPA changes workload replica counts, KEDA connects event-driven signals to scaling, VPA recommends or adjusts per-Pod resource sizing, and Karpenter supplies and manages nodes. A typical setup scales Pods first as demand rises, then provisions nodes when those Pods cannot be scheduled; as demand falls, workload scaling reduces Pods and node autoscaling can consolidate unused capacity.
What each Kubernetes autoscaler controls
These tools are complementary rather than four interchangeable ways to scale the same thing. Choose them according to the resource or signal you need to manage.
As an Amazon Associate I earn from qualifying purchases.
| Component | What it changes | Typical signal or role |
|---|---|---|
| HPA | The desired replica count of a workload | CPU, memory, custom, or external metrics |
| VPA | Per-Pod resource recommendations and, depending on configuration, requests or limits | Observed and historical resource use, availability, and events such as out-of-memory conditions |
| KEDA | Event-driven workload activation and scaling integration | External event sources, with HPA handling scaling above one replica |
| Karpenter | Node capacity and node lifecycle | Pending Pods and the operator’s NodePool configuration |
How HPA and Karpenter work together
HPA adjusts a workload’s desired replica count; it does not provide the machines those replicas need. When more replicas are requested, the scheduler tries to place their Pods using resource requests and scheduling constraints. If a Pod cannot fit on available nodes, node autoscaling can provision suitable capacity. Karpenter uses NodePool configuration to provision nodes directly from provider resources rather than depending on preconfigured node groups, and it also supports broader node lifecycle tasks such as refreshing or upgrading nodes.
The reverse sequence is also important: when workload scaling removes Pods, the remaining workload may fit on fewer nodes, allowing node autoscaling to consolidate capacity. This is a coordination pattern, not a guarantee that every pending Pod can be placed: requests, affinity, topology, storage, and provider support all affect whether a suitable node can run it.
#1 Best Overall
Why resource requests matter
HPA’s utilization-based CPU or memory targets are calculated relative to requested resources, so missing or unrealistic requests can undermine those decisions. Node autoscalers also use Pod requests when deciding whether a pending Pod fits and whether a node can be consolidated. Requests therefore connect workload-level scaling to capacity planning; they are not merely bookkeeping values.
When to use HPA, and what it needs
Use HPA when the desired response is a changing replica count driven by resource utilization or another supported metric. The autoscaling/v2 API supports custom and multiple metrics. When several metrics produce replica recommendations, HPA chooses the largest desired count, subject to the configured maximum.
HPA needs the relevant metrics API to be available. Resource metrics are provided through metrics.k8s.io, commonly by metrics-server; custom or external metrics require their corresponding APIs and sources. HPA’s behavior settings can define scale-up and scale-down policies, stabilization windows, and tolerance to control scaling rates and reduce flapping. Configurable HPA scaling behavior has been stable since Kubernetes v1.23.
When KEDA is a better fit for event-driven workloads
KEDA is useful when an event source—such as a queue—better represents demand than CPU or memory usage. It monitors event sources and exposes metrics for Kubernetes HPA. KEDA’s operator manages the HPA lifecycle and handles activation between zero and one replica; HPA handles scaling above one. For a queue-driven worker, that allows pending messages to activate the workload and an idle queue to permit scale-to-zero.
Rank #3
CPU and memory triggers have a different path: HPA reads those metrics from metrics-server directly. KEDA’s concepts documentation says these triggers do not support scaling from zero, because with no running Pods there are no Pod metrics to signal that the workload should reactivate. If zero replicas are a requirement, select an event source that can still report demand while the workload is stopped.
What VPA changes—and what it does not
VPA focuses on how much CPU and memory each Pod should request or be limited to, rather than how many replicas should run. It is a separately installed add-on, not part of the core Kubernetes API. Its recommender, updater, and admission controller use observed and historical usage, resource availability, and events such as out-of-memory conditions to produce recommendations and apply them according to the chosen configuration. VPA needs a metrics source such as metrics-server.
VPA and Kubernetes in-place Pod resizing are not interchangeable. Kubernetes documents in-place vertical scaling as stable since v1.35, but its documentation says that as of Kubernetes v1.37 VPA does not support resizing Pods in-place and integration work is ongoing. Do not assume that enabling VPA will resize an existing Pod in-place.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Combining vertical and horizontal scaling requires care because VPA changes requests that influence utilization-based HPA decisions and node-capacity calculations. Kubernetes also cautions against using VPA on DaemonSet Pods in conjunction with node autoscaling: changed DaemonSet resource predictions can make node-capacity estimates unreliable.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.A practical sequence for coordinating the loops
- Choose the demand signal. Use resource utilization or custom metrics with HPA, or use KEDA when an external event source should drive activation and scaling.
- Set workload scaling behavior. Define the replica range and, for HPA, the relevant metrics and rate or stabilization controls. For KEDA, configure the event source and its activation behavior.
- Make Pod requests and constraints realistic. The scheduler uses resource requests and scheduling requirements to place Pods, while node autoscaling uses requests to reason about capacity.
- Configure node provisioning for the workloads. With Karpenter, define NodePools and verify that the provider implementation can satisfy the workload’s resource and scheduling requirements.
- Observe both scale-up and scale-down. Confirm that rising demand creates replicas, that unschedulable Pods can obtain capacity, and that reduced demand allows workload and node capacity to contract appropriately.
- Introduce VPA deliberately. Use its recommendations or configured adjustments to improve sizing, then review how request changes affect HPA and node provisioning before combining the loops.
How to choose the combination
- Need more or fewer copies of an application? Start with HPA, or KEDA when event-source metrics or zero-replica activation are central.
- Need better per-Pod sizing? Use VPA recommendations or configured resource adjustments, while accounting for their effects on HPA and scheduling.
- Need nodes when Pods cannot schedule? Add a node autoscaler such as Karpenter, configured for the provider and constraints in your environment.
- Need to scale idle workers to zero? Prefer a KEDA event trigger that can observe demand without running Pods; CPU and memory triggers do not provide that zero-to-one signal.
- Need a specific cloud integration? Verify its current provider implementation and version. Kubernetes documentation describes fewer Karpenter integrations than Cluster Autoscaler’s and gives AWS and Azure as examples; that is not a guarantee of feature parity for a particular release or environment.
Feature status and provider implementations change. Kubernetes and KEDA documentation reviewed on October 7, 2026, identifies HPA configurable behavior as stable since v1.23, VPA as stable since v1.25, and in-place Pod vertical scaling as stable since v1.35; it also states that VPA does not support in-place resizing as of v1.37. Check the documentation for the Kubernetes release and provider you actually run before implementation.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
