Techbanq

Cloud · Kubernetes cost

The cluster bills for what your pods request, not what they use

Kubernetes was sold internally as efficiency, and the invoice says otherwise. The usual reason is mechanical: nodes are bought to satisfy resource requests, requests were set by copy-paste and fear, and the gap between requested and used is paid for every hour. The gap is measurable, and closing it is engineering, not negotiation.

Serving Saudi Arabia from our Riyadh office and our engineering hubs in Lahore and Karachi

Market
Saudi Arabia
Written for
CTO, COO
Decision
Understand why the Kubernetes migration raised the bill and what brings the cluster cost down
Languages
EN · AR

Enterprise delivery credentials

  • ISO

    ISO/IEC 27001

    ISO/IEC 27001 certified

Certifications & registrations

The cost drivers

Four ways a cluster bill parts company with actual usage

This page is about the cluster specifically; the whole-account bill has its own anatomy and its own page. Inside the cluster, the money leaks through four gaps, and the first is by far the widest.

VariableEffect on priceWhy
Requests set by fear, not measurementNodes purchased to reserve capacity the pods never touchThe scheduler places pods by their requests, and the cluster buys nodes to honour them. Requests are typically copied from a template or padded "to be safe", so the cluster runs out of schedulable capacity — and buys more — while the machines themselves sit largely unused. This is the defining Kubernetes cost mechanism: you pay for the reservation, not the work.
Node shapes the pods cannot fillStranded slivers of CPU and memory on every nodeBin-packing is real geometry: pods of awkward sizes leave unusable remainders on every node, and a fleet of one node shape rarely fits a mixed workload. Memory-hungry pods strand CPU; CPU-hungry pods strand memory. The remainders are paid for on every node, every hour.
Non-production clusters that never sleepDevelopment and staging billed around the clock for office-hours workEvery team gets a cluster, every cluster mirrors production sizing, and all of them run through nights, weekends and holidays serving nobody. Unlike production, this waste needs no analysis — a schedule that scales non-production to zero outside working hours is the rare cost fix with no trade-off to debate.
The orchestration overhead, multiplied by environmentsA fixed tax per cluster that the VM estate never paidControl planes, system pods, monitoring agents and ingress controllers consume capacity on every cluster before the first application pod starts. Per cluster it is modest; across a cluster per team per environment, it becomes a standing charge the old VM estate simply did not have.

Ask any supplier quoting this

  • For our ten largest workloads, what is the measured usage against the requested capacity, over what window was it measured, and what would the requests be if they were set from that data?
  • Which of our clusters could scale to zero outside working hours, and what stops that being turned on this month?

The method

Closing the request-to-usage gap without gambling on stability

Cutting requests blindly trades a cost problem for an outage problem — too-tight limits get pods evicted or throttled at the worst moment. The discipline is measurement first, one workload class at a time.

STAGE 01

Measure usage per workload over a real window

Actual CPU and memory consumption, recorded across weeks that include the workload’s own peaks — month-end, campaign days — because a request set from a quiet fortnight recreates the problem in reverse. A requested-versus-used chart per workload.

STAGE 02

Reset requests and limits from the data

Requests move to observed usage plus a deliberate margin; limits are set by each workload’s tolerance for throttling or eviction. Changes roll out gradually with eviction and throttling watched, and reversed where the measurement missed something. Requests that reserve what the work needs, with a margin.

STAGE 03

Reshape the nodes around the real pods

With honest requests, the bin-packing problem becomes solvable: node sizes and families are rechosen to fit the actual pod mix, and the cluster autoscaler consolidates what the old shapes stranded. Fewer nodes carrying the same workloads.

STAGE 04

Put the idle estate on a clock

Non-production clusters scale to zero outside working hours and rebuild on demand; ephemeral environments replace standing ones where the workflow allows. The change is organisational as much as technical — teams have to trust that the environment comes back. Environments billed for the hours they are used.

The harder question

Some workloads should leave the cluster rather than be tuned inside it

Kubernetes earns its overhead when the workload actually uses what it provides: many services deployed independently, demand that varies enough for scheduling to matter, teams that ship frequently enough to need the machinery. A workload with none of those traits — the steady monolith, the pair of internal tools, the database that was happier on its VM — pays the orchestration tax and collects nothing for it. It needs the cluster kept, patched and staffed, and in return it gets scheduling flexibility it never exercises.

Saying so out loud is hard because the migration was somebody’s project, argued for and celebrated. But the sunk cost is sunk either way, and the estate that costs least is usually mixed: the genuinely dynamic services on the cluster, the steady workloads on plain VMs or simpler managed runtimes, and nobody forced onto an orchestrator for the architecture diagram’s sake. Moving a workload off Kubernetes is not an admission the platform failed — it is the same sizing discipline as the requests, applied one level up.

Our role

What we resize in the cluster and which verdicts stay yours

  1. 01

    The gap, measured first

    We put requested capacity next to measured usage for every workload and rank the gaps, so the effort starts where the reservation-to-work distance is widest and the evidence is in front of you before anything changes.

  2. 02

    The resize, run as production change

    Requests, limits, node shapes and non-production schedules change gradually, watched for eviction and throttling, and reversed where needed — the bill comes down without stability being spent to pay for it.

  3. 03

    The fit-for-cluster verdict, given honestly

    Where a workload does not use what Kubernetes provides, we say so and cost the alternative — including when the alternative is a plain VM, and including when the honest answer reflects on a migration we were not part of.

Which workloads stay on the cluster and which leave it are architecture decisions you own; we give you the requested-versus-used evidence, an estate resized without incident, and schedules that stop the idle hours billing.

Common questions

What buyers ask

We moved to Kubernetes to save money. Why did the bill go up?+

Because the efficiency argument assumed honest resource requests, and migrations almost never produce them. On VMs, a service’s footprint was whatever its machine was; during migration, that machine size — or a padded guess — became the pod’s request, and the scheduler has been reserving it ever since. Add node shapes chosen before anyone knew the real pod mix, a cluster per team per environment running around the clock, and the orchestration overhead each cluster carries, and the bill rises even though utilisation fell. None of this is inherent to Kubernetes: the same mechanisms that inflate the bill — requests, packing, scaling — are the controls that bring it down once they are set from measurement instead of migration-day guesswork.

Is cutting resource requests safe, or will it cause outages?+

Done from measurement and in stages, it is one of the safer infrastructure changes; done from a spreadsheet in one afternoon, it is how you convert a cost problem into a reliability one. The risks are specific: a memory limit set below a workload’s real peak gets its pods killed, and a CPU request set too low gets it throttled exactly when it is busiest. Both are avoided the same way — measure across a window that includes the workload’s genuine peaks, keep a deliberate margin above observed usage, change one workload class at a time, and watch eviction and throttling signals after each step with the previous values ready to restore. The workloads to leave until last are the ones whose failure is expensive: databases, payment paths, anything with state.

Should some of our workloads come off Kubernetes entirely?+

Ask what each workload takes from the platform. A workload earns its place by using what Kubernetes provides — independent deployment of many services, scheduling across variable demand, frequent releases through the same machinery. A steady monolith, a low-traffic internal tool or a database that ran contentedly on its VM uses none of that, while still requiring the cluster to be maintained under it. For those, a plain VM or a simpler managed runtime often costs less in both money and attention, and moving them out also shrinks the cluster the remaining workloads pay for. The obstacle is usually organisational — the migration was recent and defended — but the cheapest estates we see are mixed by design, and treat the orchestrator as a tool some workloads need rather than a destination all workloads owe.

Read the cluster bill with us

A cluster review that puts requested capacity next to measured usage for every workload, and says plainly which of the four cost drivers your bill is made of.

Start the conversation