Kubernetes dev cluster cost consists mostly of items that need no load: the cluster fee, the NAT gateway, the ingress load balancer, the minimum number of nodes in the system pool and the agents on them. These fixed costs accrue per cluster, and whoever runs one cluster per environment, dev, staging, QA, preview, multiplies them by the number of environments before the first workload runs. This page adds up a cluster's fixed costs, sets namespace per environment against cluster per environment, describes scale-to-zero and schedules for environments nobody uses at night, preview environments per pull request, and what parity with production really requires. The cloud costs of non-production environments outside the cluster are the article non-production cloud costs.

How it works

A cluster has four fixed items. The control plane fee, per cluster and hour, USD 0.10 in the standard tier at all three providers, zero in the AKS Free tier and credited once per billing account at GKE (EKS, AKS and GKE fees compared). The network: a NAT gateway per cluster or zone, a load balancer per ingress, public addresses (services, load balancers and egress). The minimum nodes: a system pool that never reaches zero because CoreDNS, the agents and the add-ons need a place, required at AKS and usual at the others. And the add-ons themselves, the logging, monitoring and cost agents per node and the controllers per cluster (shared cluster costs). The environment's workloads come on top, and only they tell dev from staging.

Two models distribute environments. Cluster per environment separates them completely: own control plane, own network, own nodes, own access rights, own upgrades, and all four fixed items per environment. Namespace per environment puts them into one cluster: the fixed items accrue once, the environments share nodes and can be separated with resource quotas, network policies and pod security standards, but not at the level of the control plane or the network. In between sits one cluster per environment class: one for everything non-production with a namespace per environment, one for production.

a cluster perenvironmenta cluster perenvironment classa namespace perenvironmentThe environmentsDistributed how?Complete separation: owncontrol plane, network,nodes, access and upgrades;all four fixed itemsper environmentOne for everything non-production with a namespaceper environment, onefor productionThe fixed items once; sharednodes; separation by quotas,network policies and podsecurity, not at thecontrol plane
A cluster per environment pays the four fixed items each time, a namespace per environment pays them once, and a cluster per environment class sits in between

Non-production environments have a usage time production does not. A schedule scales the user pools to zero in the evening and back in the morning, through the pool's minimum size or a CronJob; the cluster fee and the system pool keep running. AKS can stop a whole cluster, control plane and nodes, and keep its state for up to twelve months, not for clusters with node auto-provisioning. In GKE Autopilot and on Fargate, pods scaled to zero leave the bill at once because there are no nodes (HPA, VPA, KEDA and the bill). Preview environments per pull request are the extreme: one namespace per branch, created by CI, with a lifetime after which a controller deletes it; without that deadline namespaces pile up whose branch was merged long ago.

Parity with production means the same Kubernetes version, the same add-ons, the same manifests and the same topology where it changes behaviour; it does not mean the same node count, the same instance sizes, three zones or a cluster of its own. A staging with one replica on small nodes checks that the software runs; a load test needs production size for hours, not months.

AWS

An EKS cluster costs the fee as long as it exists; node groups can scale to zero, the control plane cannot be stopped. NAT gateways are billed per hour and gigabyte even when no pod runs.

Azure

AKS in the Free tier takes the fee off development clusters, and a cluster can be stopped and later started with its state.

Google Cloud

One zonal or Autopilot cluster per billing account is fee-free through the credit; Autopilot bills only the pods that run, and an Autopilot cluster without pods costs only the fee.

What it means for your cost

The decision is the number of clusters, not the number of environments. Every cluster brings its fixed items, and a non-production cluster carries them for an environment that is empty at night, at the weekend and between two test runs. One cluster for all non-production environments with a namespace per environment divides the fixed items by the number of environments and lets the workloads share the nodes; the price is the shared control plane that goes through an upgrade and an outage together. Separate clusters pay off where separation is the purpose: a cluster for testing upgrades and add-ons, a cluster with different access rights, a cluster in another region.

noyes: upgrade tests,a tenant of its ownIs separationthe purpose?One cluster for all non-productionenvironments, a namespace each:the fixed items divided, thenodes sharedA separate cluster, withits fixed itemsA schedule sets the user pools tozero for two thirds of the week:the node hours changeOnly one cluster fewer changesthe fixed items
The number of clusters is the decision: a schedule changes the node hours, only one cluster fewer changes the fixed items

In billing data environments are visible only when the cluster or the namespace carries a tag or label environment that reaches into the allocation (cost per customer, feature and environment). Only then can the number that matters be computed: the non-production clusters' share of Kubernetes cost and the fixed items' share of that. A schedule that sets the user pools to zero for two thirds of the week changes the node hours; only one cluster fewer changes the fixed items.

Where it goes wrong

  • One cluster per developer. Symptom: twenty clusters, each with fee, NAT and system pool, each almost empty. Cause: environments were created as clusters because a namespace counted as too little separation; the fixed items run twenty times.
  • Schedule without effect. Symptom: the user pools are at zero at night, the bill barely falls. Cause: cluster fee, NAT, load balancer and system pool keep running; they were the larger part.
  • Preview namespaces without a deadline. Symptom: the non-production cluster has a hundred namespaces and grows. Cause: preview environments are created per pull request but never deleted; the nodes stay.
  • Production size in staging. Symptom: staging costs as much as production. Cause: parity was read as the same node count and instance size instead of the same version and manifests.
  • Environment without a label. Symptom: the cost of the non-production environments cannot be put in a number. Cause: neither clusters nor namespaces carry an environment label; the allocation knows only nodes.
  • Stopped cluster forgotten. Symptom: an AKS cluster cannot be started after months. Cause: a stopped cluster's state is kept for twelve months; after that it is lost.

Example

List prices read on 2026-10-21: Amazon EKS USD 0.10 per cluster and hour; in Frankfurt (eu-central-1) NAT gateway USD 0.052 per hour before traffic, Application Load Balancer USD 0.027 per hour before capacity units, m6i.large (2 vCPU, 8 GiB) USD 0.115 per hour on demand under Linux.

The fixed items of a cluster with two m6i.large in the system pool come to 73.00 (fee) + 37.96 (NAT) + 19.71 (load balancer) + 167.90 (two nodes) = USD 298.57 in a 730-hour month, before any workload. Four environments as four clusters cost 4 × 298.57 = USD 1,194.28 of fixed items a month; as four namespaces in one cluster, USD 298.57. A schedule that runs the user pools of dev and staging for twelve hours on weekdays only lowers their node hours to 60 of 168 hours a week, 36 percent; two user pools of two m6i.large each then cost 0.36 × 335.80 = USD 120.89 instead of USD 335.80, while the clusters' fixed items stay as they were.

Sources

Read on 2026-10-21. Amazon EKS pricing, AWS Price List bulk API, offers AmazonEC2, AWSELB and AmazonVPC, eu-central-1, Microsoft stop and start an AKS cluster and AKS cluster management pricing tiers, Google Cloud GKE pricing, Kubernetes namespaces and resource quotas.