None of the three autoscalers lowers a cloud bill by itself. HPA changes how many replicas of a workload run. VPA changes the CPU and memory each Pod requests. KEDA reads event sources such as queues and can scale eligible workloads down to zero replicas. Each of those actions saves money only when it frees capacity that the cluster can turn into fewer nodes. The cheapest option is therefore the one that matches your workload and whether your node layer can act on the change.
What each autoscaler actually changes
The Kubernetes documentation describes autoscaling as “the ability to automatically update an object that manages a set of Pods (for example a Deployment).” That definition shows the limit shared by all three tools: each one edits a workload object, and none of them edits the node pool underneath it.
As an Amazon Associate I earn from qualifying purchases.
HPA: changes how many replicas run
The Horizontal Pod Autoscaler runs as a periodic control loop and adjusts the replica count of a scalable workload, usually a Deployment. It can read CPU and memory, custom metrics, and external metrics. When you configure several metrics, it calculates a recommendation for each and applies the largest one.
Quick wins for a faster PC:
Scan for outdated or missing drivers - takes under a minuteDriver Scan →Clear out junk files and repair common Windows errorsFree Scan →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →CPU-based scaling is measured against Pod resource requests, not against the node. A Pod that requests 500m CPU and uses 400m reports 80 percent utilization. If the same Pod requests 2 CPU, the same 400m reads as 20 percent, and HPA has no reason to add replicas. Requests set too low do the opposite and cause over-scaling. Scale-up and scale-down speed come from HPA defaults and any behavior block in the manifest, so check both in the Kubernetes release you run instead of assuming a response time.
#1 Best Overall
VPA: changes Pod requests and limits
The Vertical Pod Autoscaler is a separate add-on, not part of a base Kubernetes install. It has three components. The recommender analyzes historical and current usage. The admission controller applies recommendations when Pods are created. The updater can evict running Pods so they restart with new values. Which of these actions take effect depends on the update mode you set. In Off mode, VPA only publishes recommendations, so you can read them before anything changes.
Treat the resource policy as a control, not a detail. Minimum and maximum bounds per container stop VPA from recommending values too small to run well or too large to schedule on your node types. Without bounds, a rightsizing pass can produce requests that no node in your pool can fit.
VPA’s effect on cost is indirect. It lowers the capacity each Pod reserves, which lets the scheduler pack more Pods onto each node. It does not reduce the replica count.
Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minuteWindows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallKEDA: scales from event sources and can reach zero
KEDA does not replace HPA. A scaler watches an event source such as a queue, database, or telemetry system, and KEDA supplies that signal to HPA. You describe the workload and its triggers in a ScaledObject, and KEDA creates and manages the HPA for it. Between zero and one replica, KEDA acts on the event signal. Above one replica, HPA does the scaling, using the metric KEDA provides.
Rank #3
Scale to zero is what separates KEDA from the other two, and it has one hard limit. A workload at zero replicas has no Pods reporting CPU or memory, so a CPU or memory trigger cannot wake it. The wake-up signal has to come from an event source the scaler can read, such as queue depth. Scaler behavior and limits are specific to each scaler and version. The KEDA 2.22 concepts documentation states that this version is not the latest release, so confirm the scaler details in the version you deploy.
Side by side
| Dimension | HPA | VPA | KEDA |
|---|---|---|---|
| Primary action | Changes replica count | Changes Pod CPU and memory requests, and limits per policy | Changes replica count through HPA, including activation from zero |
| Signals | CPU, memory, custom and external metrics | Historical and current resource usage | Event sources read by scalers, such as queues and databases |
| Installation | Built into Kubernetes; resource metrics need a metrics pipeline | Separate add-on with recommender, admission controller, and updater | Separate install that works alongside HPA |
| Minimum replicas | Default minimum of one | Not applicable; does not change replica count | Zero for eligible event-driven workloads |
| Node-bill lever | Frees capacity only if nodes can be removed or emptied | Smaller reserved requests improve packing and consolidation | Idle event-driven workloads release their Pods; nodes still have to scale down |
Why the bill does not follow the replica count
Node autoscaling is a separate infrastructure layer. It works with the cloud provider’s APIs to add or remove nodes, and it typically acts when Pods cannot be scheduled or when nodes stay underused. A workload scaler alone does not change that layer, so it does not change the invoice directly.
The Kubernetes documentation makes the connection explicit: “Correctly setting the resource requests of your Pods is as important to the overall cost-effectiveness of a cluster as optimizing Node utilization.”
A simple illustration, not a benchmark: suppose each replica requests 1 vCPU, each node has 4 vCPU allocatable, and system overhead is ignored. Twelve replicas occupy three nodes. Cutting to six replicas needs only two nodes, so one node can go. If those six replicas end up spread two per node across all three nodes, though, no node is empty and nothing is freed.
Best Value
Choosing by workload type
Stateless services with variable request load
HPA is the usual starting point. Set realistic requests first, because the CPU signal depends on them.
Steady services with oversized requests
VPA is the rightsizing tool here. Run it in Off mode for a representative period, compare its recommendations with observed usage, and then apply changes through a controlled rollout within your minimum and maximum bounds. Do not run VPA in an applying mode and HPA against the same CPU or memory signal on one workload without first checking the VPA documentation for that combination.
Queue consumers and scheduled event work
KEDA fits workloads whose demand is visible in an event source, such as queue depth or stream lag. This is the case where scale to zero can remove Pod-hours outright. Check the exact scaler and its limits for your event source, and measure how long the first event takes to process, because a zero-scaled workload must start Pods before it can do any work.
Free tools Windows power users keep installed
One-click scans. No signup required.
Combining them
Many clusters use more than one tool. A KEDA-managed workload is handled by HPA once it is above zero, so the request-sizing caveat still applies. One practical pattern is to run VPA in Off mode to read recommendations, set requests by hand, and let KEDA or HPA control the replica count.
Measure the bill, not the replica count
- Baseline the cost drivers. For a full traffic cycle, capture replica-hours per workload, requested versus used CPU and memory, and node-hours per node pool. Use
kubectl get hpa --all-namespacesto see current scaling state,kubectl describe vpa my-app -n my-namespaceto read VPA recommendations (the VPA resource must be installed first), andkubectl top pods -n my-namespacefor live usage, which requires metrics-server. - Change one variable at a time. Introduce one autoscaler per test, and compare periods with equivalent traffic or queue volume rather than identical clock hours.
- Keep the floors visible. Record minimum replicas, VPA minimum bounds, and any PodDisruptionBudget, since each sets the lowest cost you can reach.
- Measure the cost of scaling. Track scale-up latency, time to first processed event for zero-scaled workloads, and latency and error rate during scaling events.
- Price the nodes you actually run. Convert node-hours to money using your provider’s billing data for each node pool, including any discounts or commitments that apply to you.
When the bill does not move
- Replica count fell but node count did not. Check whether the remaining Pods are spread across every node by topology spread or anti-affinity rules, whether a disruption budget blocks drains, and whether Pods with local storage prevent node removal. Then review the node pool’s scale-down settings.
- HPA does not add replicas under load. Compare observed CPU to the requests in the manifest. Requests far above real usage hide demand.
- A KEDA workload never wakes. Confirm the trigger reads an event source. A CPU or memory trigger cannot start a workload with no Pods.
- The first event is slow. Time Pod start and image pull. If the delay is unacceptable, a minimum of one replica removes the zero-cost benefit, so the trade-off should be a deliberate choice.
- VPA changes Pods unexpectedly. Check the update mode and PodDisruptionBudgets before applying recommendations to running workloads.
Sources and versions
- Kubernetes documentation for the Horizontal Pod Autoscaler, the Vertical Pod Autoscaler, Pod resource requests, and node autoscaling, as current at the time of writing.
- KEDA 2.21 documentation, for how KEDA integrates with HPA.
- KEDA 2.22 documentation, for concepts and scale-to-zero constraints. That page states it is not the latest version.
- Google Cloud documentation for a GKE tutorial that deploys KEDA with scale to zero. The tutorial lists which cloud components are billed in that setup, so compare that list with your own architecture. It is an implementation example for one platform, not evidence that the platform is cheaper.
The official material does not publish a general savings percentage or a benchmark ranking HPA, VPA, or KEDA on cost. Verify your Kubernetes, VPA, KEDA, and cloud-provider versions before you copy any manifest, because APIs, scaler support, and pricing change.
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.
