Date:
Category:
DevOps Strategy
Kubernetes Cost Optimization: A Practical Guide for AWS Teams

Written by
Dino Starcic
·
CEO

Kubernetes cost optimization means paying only for the compute, storage and network your workloads actually use, without hurting performance. The order matters: measure first, rightsize workloads second, then autoscale and clean up. Discounts and bin packing come last. Most teams know this and still don’t do it, because it is steady, senior-level work that competes with product deadlines. That is why many startups hand it to a monthly AWS and DevOps subscription instead of waiting for someone on the team to find the time.
This guide gives you the routine, the thresholds and the failure points. It is written for teams running Kubernetes on AWS, though the principles hold on any cloud.
CloudwiseKeep Kubernetes Costs Under ControlCloudwise provides AWS and DevOps support for cost optimization, infrastructure management, security monitoring, and day-to-day cloud operations.Visit
TL;DR
Typical clusters run at only 20 to 30% resource utilization while you pay for 100% of provisioned capacity, so the waste is large and usually fixable.
Rightsizing pod CPU and memory requests is the biggest and fastest saving. Do it before buying discounts or tuning node packing.
Allocate cost to teams and namespaces first, or nobody owns the bill.
Then autoscale, shut down non-production environments out of hours, and remove orphaned resources.
Treat it as a monthly loop, not a one-time project. Our Kubernetes and FinOps engineers can run that loop for you through a single subscription.
Table of Contents
Why Kubernetes bills drift upward
The order that saves the most
Step 1: Measure before you change anything
Step 2: Allocate costs so someone owns them
Step 3: Rightsize requests and limits
Step 4: Autoscale pods and nodes
Step 5: Remove idle and orphaned spend
Step 6: Review monthly
What this looks like in a real week
How Cloudwise handles Kubernetes cost work
Common mistakes to avoid
FAQ
Sources
Why Kubernetes bills drift upward
Kubernetes makes it easy to ask for resources and hard to see what they cost. A developer sets a CPU and memory request once, generously, to be safe. The scheduler reserves that capacity on a node, and you pay for the node whether the pod uses the reservation or not.
AWS’s EKS cost guide names six drivers that compound each other: idle resources, over-provisioning, inefficient autoscaling, legacy x86 workloads that miss Graviton’s roughly 20% price-performance improvement, monitoring overhead and manual management. The same guide says up to 70% of compute spend in a typical cluster delivers no workload value.

Google’s research points the same way. Its State of Kubernetes Cost Optimization study found that workload requests are substantially over-provisioned on average and that rightsizing is the biggest opportunity to reduce waste. Clusters in its top performance tier rightsized CPU 2.8 times better and memory 2.7 times better than the lowest tier, and could scale down four times more capacity off-peak.
The takeaway for a business owner: the savings are not hiding in an exotic setting. They sit in everyday configuration that nobody has had time to revisit.
The order that saves the most
AWS’s EKS best-practices documentation ranks the work in three steps: right-size workloads, reduce unused capacity, then optimize compute capacity types such as Spot. Google’s study gives the same warning: focusing on bin packing or discounts first may mean redoing the work later, because the numbers you commit to change once workloads shrink.
A workable loop looks like this:
Measure what each workload uses.
Allocate that cost to an owner.
Rightsize requests and limits.
Autoscale pods and nodes.
Remove idle and orphaned resources.
Review monthly and repeat.
The sections below take each step in turn, with where it usually goes wrong.
Step 1: Measure before you change anything
You cannot rightsize what you cannot see. At a minimum you need per-pod CPU and memory usage over time, tied to the workload that produced it. A common baseline is at least 7 days of data, and 14 to 30 days is better because it catches weekly and month-end peaks.
Look at percentiles, not averages. The median (p50) shows normal load. The 95th and 99th percentiles (p95, p99) show how high usage goes during spikes. Sizing from an average is how teams end up with out-of-memory crashes at the busiest hour.
A few reference points help you read the numbers:
Google Kubernetes Engine flags a workload as underprovisioned when CPU or memory use exceeds 150% of the request for at least 10% of the time over 15 days, and overprovisioned when use stays below 50% for at least 90% of that time.
The same page warns that visibility into Java memory is limited, so Java workloads need extra scrutiny before you trim them.
Where it goes wrong: short measurement windows. A week that missed the monthly billing run will make a batch job look tiny. Collecting the data is easy. Interpreting it per workload is the part that takes experience.
Step 2: Allocate costs so someone owns them
A cluster bill is one number. Optimization needs it split by namespace, team or product. Kubernetes cost is mostly compute, network and storage, so the split has to cover all three.
The practical basics:
Enforce consistent labels (team, service, environment) on every workload. Unlabeled spend is unowned spend.
Divide each node’s cost across the pods on it, by their share of CPU and memory.
Decide how to handle shared and idle capacity, write the rule down and apply it the same way every month.
Start with showback (showing teams their cost) before chargeback (billing it to their budget).
Google’s documentation says to enable GKE cost allocation to attribute costs to namespaces and labels and export the data for analysis. On AWS, the same idea applies through tagging and a cost-allocation tool that understands pods.
One caution from Google’s study: clusters that use far more memory than they requested, about 60% more in its at-risk group, make request-based allocation inaccurate. Fix the requests and the allocation gets more trustworthy too.
Step 3: Rightsize requests and limits
This is the highest-return step. A request is what the scheduler reserves. A limit is the ceiling a container may reach. They behave differently:
CPU is compressible. If a container hits its limit, it gets throttled and slows down.
Memory is not compressible. Memory limits are enforced by the kernel through out-of-memory kills, so a limit set too low restarts your app.
That difference sets your caution level. Be generous with memory, tighter with CPU requests, and loose on CPU limits.
A safe rightsizing routine
Run the Vertical Pod Autoscaler (VPA) in recommendation-only mode. AWS suggests using it in auditing mode so it suggests request and limit changes without restarting pods.
Rank workloads by absolute dollars wasted, not percentage. A service at 5% utilization that costs $40 a month matters less than one at 60% costing $20,000.
Set new requests from p95 usage plus headroom, and keep memory limits comfortably above observed peaks.
Test the change in a non-production environment first. AWS states that production-affecting changes can alter reliability and performance.
Roll out in stages, one service at a time, and watch error rates and latency for at least a day after each change.
Keep stateful and critical-path services on manual review. Automated resizing suits stateless services that already scale horizontally.
Since Kubernetes 1.35, in-place pod resize is stable (first available in 1.27). You can change CPU and memory on a running pod without recreating it, and a resize policy controls whether a restart is required. That lowers the risk of each adjustment, provided your cluster version supports it.
Where it goes wrong: trimming a memory request to match the average, then watching pods get evicted at peak. Also, running VPA and the horizontal autoscaler on the same CPU or memory metric makes them fight each other.
Step 4: Autoscale pods and nodes
Rightsized pods only save money if the nodes underneath shrink with them. Google describes autoscaling as starting workloads and infrastructure before demand rises and shutting them down when it falls. Three layers work together:
Horizontal pod autoscaling adds or removes replicas with load.
Vertical autoscaling adjusts the size of each pod’s request.
Node autoscaling adds or removes machines so empty capacity does not sit idle.
Event-driven scaling goes further. It can scale a workload to zero based on queue depth or a schedule, which suits background workers and non-production environments.
Guardrails keep this from backfiring. Set namespace-level limits and quotas so a misconfigured autoscaler cannot provision a fleet of expensive nodes overnight.
Pick cheaper capacity once the workload is right-sized
Only after rightsizing should you change the purchasing model:
Move fault-tolerant workloads (stateless web tiers, batch, CI runners) to Spot capacity. Microsoft’s AKS guidance cites savings of up to 90% for Spot VMs and up to 72% for reserved instances. Those are Azure figures, but the pattern is the same on AWS.
Evaluate Arm-based Graviton instances for workloads that can run on them, given the price-performance gain AWS cites.
Cover your steady baseline with commitments, sized to the post-rightsizing footprint.
Where it goes wrong: buying a one-year commitment based on today’s bloated footprint, then shrinking the workloads and paying for capacity you no longer use.
Step 5: Remove idle and orphaned spend
Some waste is not about sizing at all. The FinOps Foundation recommends removing provisioned-but-unneeded resources such as stranded storage volumes, excess snapshots and unused sandboxes, scheduling pre-production resources to start and stop, and automating cleanup.
The usual suspects in a Kubernetes environment:
Dev and staging clusters running 24/7. If your team works eight hours a day, those environments sit idle about two thirds of the time.
Persistent volumes left behind by deleted workloads.
Load balancers with no backends.
Zombie deployments from finished projects or departed engineers.
Oversized batch jobs.
Logs and metrics deserve a look too. Google notes that logging and monitoring charges grow with log volume, retention and the number of custom metrics. Cross-zone traffic and load balancer fees can also add up quietly. Review them like any other line item.
Where it goes wrong: deleting something that looked idle but was a disaster-recovery standby. Distinguish idle by design from genuinely unused, and confirm with the owner before removing it.
Step 6: Review monthly
Optimization decays. New services launch with copy-pasted requests, a traffic pattern shifts, a team adds a log pipeline. A monthly review keeps the gains.
Track a short list of numbers:
Cluster utilization against requests. Production targets of around 60 to 70% are common, and request efficiency below 30% is a rightsizing signal.
Idle cost as a share of the total bill.
Cost per team or per service, over time.
Percentage of spend that is labeled and allocated.
If you want a view of how your wider AWS account scores, Cloudwise’s AWS Optimisation Score is a quick place to start. For the monitoring side, our guide to AWS monitoring best practices covers what to track.
What this looks like in a real week
A small team of four to ten engineers rarely has a platform specialist. Rightsizing needs one person to read percentile data, another to ship config changes safely, and someone to watch the dashboards afterward. Each task is small. Together they are a part-time job that tends to lose to feature work.
That is the gap a subscription fills. Instead of hiring a full-time DevOps engineer or paying hourly for a one-off audit, you add the work to a shared backlog and senior engineers pick it up. Typical response time is 24 to 48 hours.
How Cloudwise handles Kubernetes cost work
Cloudwise offers Kubernetes and container platform support and cost optimization and FinOps as part of one subscription. You submit tasks like “review requests on our API namespace” or “set up a shutdown schedule for staging” to a shared backlog, and senior AWS and DevOps engineers work through them. There is no hourly billing and no long-term contract, and you can cancel anytime.

The Simplest Subscription is $7,499 per month, covering unlimited AWS and DevOps task requests, so the Kubernetes work sits alongside infrastructure, security, CI/CD and monitoring requests under the same plan. You can also see the full list of services. For deeper background on the AWS side of spend, read the hidden cost of poor AWS cost optimization.
Common mistakes to avoid
Starting with discounts. Commitments sized on an oversized footprint lock in waste.
Sizing from averages. Use p95 or p99 for anything with spikes.
Cutting memory aggressively. Out-of-memory kills cost more in incidents than the savings are worth.
Skipping ownership. Without labels, nobody acts on the numbers.
Treating it as a project. One sprint of cleanup fades within months without a review loop.
Changing production first. Test in a non-production environment, then stage the rollout.
Sources
EKS cost optimization: Scaling, sizing, and savings (AWS Prescriptive Guidance)
Design and configure GKE clusters for cost optimization (Google Cloud)
Identify underprovisioned and overprovisioned workloads (Google Cloud)
Best practices for running cost-optimized Kubernetes applications on GKE (Google Cloud)
Best Practices for Cost Optimization in Azure Kubernetes Service (Microsoft Learn)
Recommended
Questions Answered
Frequently asked questions
Clear answers to common questions about our AWS & DevOps subscription and how it works.