Cloud cost management had a workable answer before containers: tag every resource, group the bill by tag, hand each team its number. Kubernetes broke that model. A shared cluster shows up on the invoice as a pile of instances, disks, and load balancers, while the things that actually caused the spend — namespaces, deployments, batch jobs — are invisible to the billing API. FinOps for Kubernetes is the discipline of reconstructing that missing layer: allocating shared-cluster cost to teams and services accurately enough to change behavior.
This is a different problem from generic cloud cost optimization. Reservations and storage tiering still matter, but the distinctly Kubernetes problem is that the unit of spend (a node) and the unit of accountability (a workload) no longer match, and the scheduler deliberately mixes tenants to keep utilization high.
Why Shared Clusters Break Allocation
Three mechanics do the damage. First, bin packing: the scheduler places pods from many teams on the same node, so instance-level tags attribute nothing. Second, reservations: a pod's resource requests carve out capacity whether or not it is used, which means the real cost driver is what teams request, not what they consume — and nobody sees the gap. Third, idle capacity: system overhead, autoscaler headroom, and sparse nodes are real money that belongs to no workload, and unless someone explicitly owns that line it silently grows.
Instrument Before You Optimize
OpenCost, the CNCF project extracted from Kubecost's core, maps node and volume pricing onto pod resource requests over time, producing per-namespace and per-workload allocation that can be reconciled against the actual cloud invoice. If you export the data, adopting the FinOps Foundation's FOCUS specification for the format lets Kubernetes allocation rows join the rest of the bill in one warehouse instead of living in a separate dashboard.
None of it works without a labeling convention: team, service, cost center, and environment on every workload, enforced by admission policy rather than convention. A Kyverno rule that rejects unlabeled deployments in development and flags them in production is a one-day task; without it, cost reports carry a large unattributed bucket and change nobody's behavior. Decide the idle-cost policy explicitly too — spread it proportionally, bill it to the platform team, or show it as its own line. Each choice creates different incentives, and hiding it creates the worst ones.
Cut the Real Waste
- ▸Right-size requests first: the gap between requested and actually used CPU and memory is usually the largest single saving available. Run the Vertical Pod Autoscaler in recommendation mode, or Goldilocks on top of it, and feed the recommendations into pull requests rather than applying them blindly to workloads that also use horizontal scaling.
- ▸Consolidate nodes: sparse nodes are pure idle spend. Karpenter's consolidation actively replaces under-utilized nodes with fewer, better-fitting ones; with the cluster autoscaler, favor instance choices that pack your typical pod shapes cleanly.
- ▸Move the stateless to spot: interruption-tolerant workloads with PodDisruptionBudgets and graceful shutdown handling belong on spot or preemptible capacity, isolated from stateful services by node pools and taints.
- ▸Commit last, not first: buy savings plans or reservations against the steady state that remains after right-sizing and consolidation. Committing against the current bloat locks the waste in for one to three years.
Showback to Chargeback, in Order
1. Publish monthly showback per team, with the idle-cost line explicit and a named owner attached to it. 2. Review the reports with teams for a few cycles before attaching any consequences — early reports always surface allocation bugs, and credibility is hard to rebuild. 3. Set efficiency targets on the request-to-usage ratio and manage the trend rather than the absolute number, since workload profiles differ legitimately. 4. Allocate shared platform costs proportionally to consumption, never by headcount, or your heaviest users stay invisible forever. 5. Introduce chargeback only when teams hold real levers — autoscaling, right-sizing tooling, instance and storage class choices. Billing people for costs they cannot influence produces resentment, not efficiency.
The end state is worth naming: unit economics. When you can state what a tenant, a transaction, or a training run costs to serve — and see the trend — pricing conversations, build-versus-buy decisions, and capacity planning all move from intuition to arithmetic. Engineering gets a defensible answer to why does the cluster cost this much, finance gets a forecast that survives contact with reality, and the company gets margins it can actually steer. The clusters were shared all along; with this discipline, the accountability finally is too.