A cluster dashboard says CPU is at 15%. The autoscaler adds another node anyway. Finance asks why the cluster keeps growing when nothing seems busy.
Both things are true, and the reason is one setting most teams copy from a template and never revisit: resource requests.
What a request actually does.
When a pod asks for 2 CPUs and 4 GB of memory, that's a request. The Kubernetes scheduler uses requests, not real usage, to decide where a pod fits. In the docs' words, the scheduler checks that the sum of the requests of the scheduled containers is less than the capacity of the node. If the check fails, the pod isn't placed on that node, even if the node is nearly idle.
So a node is "full" when the requests add up, not when the CPUs are busy. A service that requests 2 CPUs and uses 0.2 still reserves 2 CPUs of a node you're paying for. Enough of those and the cluster needs another node, with the graphs showing a quiet system the whole time.
Why requests drift upward.
Nobody gets paged for a request that's too high. They get paged when a request is too low: throttled CPU, a pod killed for running out of memory. Memory is the sharper edge. When a container goes over its memory limit, the kernel terminates the process and Kubernetes reports it as OOMKilled. CPU is gentler, since the container is throttled rather than killed. So engineers pad requests, usually memory first, and the padding stays. It's the same pattern as the oversized instances in Issue #8, one layer up.
How cost tools see it.
This matters for allocation too. The OpenCost specification, the open standard behind the tool from Issue #6, charges workloads for the greater of what they requested and what they used. A pod that requests 4 GB and uses 1 GB is billed to its team as 4 GB. That's deliberate: the reserved capacity is what stopped other pods from landing on that node.
The spec also separates two kinds of idle. Cluster idle is capacity not allocated to any workload. Workload idle is requested resources that go unused. The first is a scheduling and autoscaling question. The second is the one teams can fix workload by workload.
The comparison worth running.
Take your top ten workloads by cost and put two numbers next to each other: what they request and what they actually use over a few weeks. Not a single peak, since peaks mislead in both directions. Look at typical and high-percentile usage across a normal period.
Where requests sit far above real usage, you have recoverable money. Where they're close, leave them alone. A few big gaps usually account for most of the waste, so this doesn't have to be a cluster-wide project.
How to lower requests without causing incidents.
Move slowly and watch what happens. Lower one workload at a time, keep some headroom above observed high usage, and treat memory more carefully than CPU, because running out of memory kills the container while CPU pressure only slows it down. Check the restart counts afterward. If you see OOMKilled, you went too far; step back up.
Lowering requests doesn't save anything on its own. The money comes when pods pack more tightly and the autoscaler removes nodes you no longer need. If node count doesn't drop, check whether something else is holding the nodes up, like large requests elsewhere, anti-affinity rules, or pod disruption settings.
Not on AWS?
None of this is cloud-specific. The scheduling behavior is Kubernetes itself, so it holds on EKS, AKS, and GKE. Some managed offerings change what you're billed for, so check whether yours charges per node or per pod before assuming the math above.
The actual takeaway: In Kubernetes, requests decide where pods fit, and nodes are where the bill comes from. If requests are padded, you pay for capacity nobody uses and the dashboards won't show it. Compare requests to real usage on your ten most expensive workloads, fix the biggest gaps first, and change them gradually.
Have you ever found a workload requesting ten times what it uses? Hit reply and tell me what you found. I read every one.
