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.

Six causes of wasted Kubernetes compute spend

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:

  1. Measure what each workload uses.

  2. Allocate that cost to an owner.

  3. Rightsize requests and limits.

  4. Autoscale pods and nodes.

  5. Remove idle and orphaned resources.

  6. 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:

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:

That difference sets your caution level. Be generous with memory, tighter with CPU requests, and loose on CPU limits.

A safe rightsizing routine

  1. 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.

  2. 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.

  3. Set new requests from p95 usage plus headroom, and keep memory limits comfortably above observed peaks.

  4. Test the change in a non-production environment first. AWS states that production-affecting changes can alter reliability and performance.

  5. Roll out in stages, one service at a time, and watch error rates and latency for at least a day after each change.

  6. 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.

Cloudwise

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

Recommended

Made using BabyLoveGrowth

Questions Answered

Frequently asked questions

Clear answers to common questions about our AWS & DevOps subscription and how it works.

What is the most effective way to manage Kubernetes costs?

Add Icon

How long should I collect data before rightsizing?

Add Icon

Do I need an in-house DevOps engineer to do this?

Add Icon

What is the most effective way to manage Kubernetes costs?

Add Icon

How long should I collect data before rightsizing?

Add Icon

Do I need an in-house DevOps engineer to do this?

Add Icon

How much can you save with Kubernetes cost optimization?

Add Icon

Is it safe to run VPA automatically in production?

Add Icon

How much can you save with Kubernetes cost optimization?

Add Icon

Is it safe to run VPA automatically in production?

Add Icon

How much can you save with Kubernetes cost optimization?

Add Icon

Is it safe to run VPA automatically in production?

Add Icon

Read More Articles