Executive Summary
Kubernetes charges for the shape of a cluster, and that shape is decided long before a FinOps dashboard opens. Requests, node sizing, and cluster count set the bill. Reporting only shows where the money went. Fix the architecture and the number falls on its own.
A container that asks for two cores gets two cores reserved whether it burns them or not, and teams copy those numbers from a tutorial and never revisit them. Half the reserved CPU sits idle while the autoscaler keeps adding nodes. Memory requests cost more, because memory cannot be compressed and padding runs past real usage. Bad requests feed Karpenter bad decisions. A single node type shapes every workload on it, whether or not the shape fits. Clusters are cheap to create and expensive to run. Ten clusters mean ten control planes, ten ingress stacks, ten monitoring agents eating CPU on every node. KEDA scales workloads to zero replicas when nothing flows. OpenCost tracks spend per namespace, and that comes after the architecture, not before. Watch the node count, not the chart.
Every platform team has a cost dashboard now. Fewer have a bill that stopped growing. The gap is not better reporting. Kubernetes charges you for the shape of your cluster, and that shape is set long before anyone opens a FinOps tool.
This is a Kubernetes cost optimization problem, but not the kind a spreadsheet fixes. The numbers come from node sizing, bin-packing, request and limit settings, and how many clusters you decided to run. Fix the architecture and the bill follows. Watch the dashboard and you only learn where the money went.
Requests and Limits Set the Price Before Any Pod Runs
Kubernetes schedules on requests, not on actual use. A container that asks for two cores gets two cores reserved whether it burns them or not. Teams copy those numbers from a tutorial and never revisit them. The result is a cluster where half the reserved CPU sits idle while the autoscaler keeps adding nodes. The resource model is doing exactly what it was told.
Memory requests matter more than CPU. Memory cannot be compressed, so a node that runs out of it starts killing pods. Teams inflate memory limits to sleep at night. You pay for that padding, and it often runs well past real usage.
The Vertical Pod Autoscaler can recommend or apply better numbers. VPA ships outside the core distribution. It needs a restart to resize in most setups, which is why many teams read its advice and hand-edit the YAML once a quarter.
Bin-Packing Collapses When Node Shapes Are Wrong
Bin-packing is how Kubernetes fits pods onto nodes. It works when nodes are sized for the workloads on them. A fleet of huge instances leaves most of each machine empty under small pods. A fleet of tiny ones leaves large pods waiting forever for a node that fits.
Karpenter reacts to demand and picks instance types as it goes. That helps, but it reacts to bad requests with bad decisions. Instance diversity is the cheap fix. One node type forces every workload into one shape. Several node pools, taints, and a scheduler that spreads pods by size will pack far tighter. None of that shows up in a cost report. It shows up as fewer nodes for the same work.
Every Extra Cluster Multiplies the Overhead
Clusters are cheap to create and expensive to run. Each one needs a control plane, ingress, logging, monitoring, certificate handling, and an upgrade path. Ten clusters mean ten of everything. Many teams split by team or environment out of caution, then pay for idle capacity in every one.
Sprawl is rarely a strategy. It is an accident with a long tail. One team needs isolation for a regulated workload, so it gets its own cluster. Another team copies the pattern. Nobody decommissions the old ones, because nobody owns the shutdown.
Namespaces and resource quotas give you tenancy inside a single cluster. That is not always the right answer for blast radius. It is often the right answer for cost. Decide on purpose, not by habit.
Scale to zero is the other lever. KEDA is a graduated CNCF project that scales workloads from events, down to zero replicas when nothing is flowing. Idle development environments cost real money when nobody turns them off.
Then there is the overhead you cannot see. Every cluster runs its own monitoring agents, log shippers, and security tooling. Those daemons consume CPU and memory on every node. Ten small clusters can spend a real share of the bill on the platform watching itself.
Then there is measurement. OpenCost is an incubating CNCF project that tracks Kubernetes spend per namespace and workload. You want it, but only after the architecture is sane. A precise bill for a badly shaped cluster is still a badly shaped cluster.
The FinOps dashboard is the last mile, not the first. Fix requests, size nodes to the work, keep clusters to the number you can actually operate, and give teams real tenancy inside one place. The bill drops because the cluster got simpler. Not because someone watched a chart.
Platform engineering is one of the forces in the 2026 State of Enterprise Infrastructure report, which covers how the operating layer changed and why maturity tracks with outcomes.
Related reading. Kubernetes for AI Is a Different Job Than Kubernetes for Apps. The Next Big AI Win Is Cutting Power Per Workload, Not Adding More Chips. The Most-Used Storage on Kubernetes Is the One You Get for Free. AI Infrastructure Runs on Four Layers. Most Break Below the Model..
Get the next one before it is old news
Independent analysis of cloud-native infrastructure, Kubernetes and data centre economics. No vendor spin.