Kubernetes vs Serverless: Cost and Complexity Compared

The Kubernetes-versus-serverless argument is usually framed as a philosophical one, and it almost never is. It is an arithmetic problem with two variables: how much of the month your code is actually running, and how much engineering salary you are willing to spend on the platform underneath it. Get those two numbers and the answer falls out.

What follows uses published list prices from AWS, Google Cloud, Cloudflare and DigitalOcean as of September 2026, plus a worked example, to show where each model breaks even.

The two cost curves

Serverless bills for work done. AWS Lambda’s published pricing is $0.20 per million requests plus $0.0000166667 per GB-second on x86 (and $0.0000133334 per GB-second on Arm), with a perpetual monthly free tier of one million requests and 400,000 GB-seconds. Google Cloud Run under request-based billing charges $0.000024 per vCPU-second, $0.0000025 per GiB-second and $0.40 per million requests in tier-1 regions such as us-central1.

Kubernetes bills for capacity reserved. On Amazon EKS the control plane alone is $0.10 per cluster per hour, roughly $73 a month, before a single worker node exists. GKE charges the same $0.10 per cluster-hour but issues $74.40 in monthly credits per billing account, which covers one zonal or Autopilot cluster. GKE Autopilot then charges per pod: $0.0445 per vCPU-hour and $0.0049225 per GiB-hour for general-purpose compute.

So the serverless curve starts near zero and rises linearly with traffic. The Kubernetes curve starts at roughly $73 a month and rises in staircase steps as you add nodes. They cross, and the crossing point is what matters.

A worked example

Take a stateless HTTP service, 100 ms of compute per request, 1 GiB of memory, no GPU. Compare three traffic levels using the list prices above. A month is treated as 730 hours (2,628,000 seconds).

1. 5 million requests/month, 150 ms each, 512 MB. That is 375,000 GB-seconds, inside Lambda’s free tier, plus 4 million billable requests at $0.20 per million. Bill: about $0.80. The equivalent EKS cluster costs $73 before you run anything.
2. 300 million requests/month, 100 ms each, 1 GiB. 30 million GB-seconds at $0.0000166667 is $500, plus $60 of request charges. Lambda: $560. The same workload is 30 million CPU-seconds a month, which is 11.4 vCPUs running flat out, or about 16 vCPUs provisioned at 70% target utilisation.
3. Sustained 16 vCPU / 16 GiB. GKE Autopilot: 16 × $0.0445 × 730 = $519.76 for CPU, 16 × $0.0049225 × 730 = $57.50 for memory, plus the cluster fee. Four DigitalOcean 8 GB / 4 vCPU droplets at $48 each: $192, with 5,000 GiB of transfer included per droplet.

The Workers figure assumes 10 ms of CPU per request against Cloudflare’s published rates: $5 a month including 10 million requests and 30 million CPU-milliseconds, then $0.30 per additional million requests and $0.02 per additional million CPU-milliseconds. It is the cheapest column by a wide margin and the most constrained runtime by a wide margin, which is the trade in miniature.

Cold starts, priced

Cold starts are a latency problem you can pay to make disappear, which turns them into a cost problem. Lambda’s provisioned concurrency is $0.0000041667 per GB-second, so keeping 1 GB warm for a full month costs about $10.95, plus a reduced $0.0000097222 per GB-second for execution while provisioned concurrency is active. The free tier does not apply once it is enabled. Cloud Run’s equivalent, idle CPU on minimum instances, is $0.0000025 per vCPU-second, roughly $6.57 per vCPU per month.

The free alternative is snapshotting. Lambda SnapStart takes a Firecracker microVM snapshot of the initialised environment at publish time and resumes from it, and AWS documents the effect as taking startup “from several seconds to as low as sub-second, in optimal scenarios.” It supports Java 11+, Python 3.12+ and .NET 8+ only, it cannot be combined with provisioned concurrency, and AWS notes it “works best when used with function invocations at scale,” which is the opposite of the infrequently-invoked function that suffers most.

Isolate-based runtimes sidestep the problem architecturally rather than commercially. Cloudflare’s documentation claims an isolate “can start around a hundred times faster than a Node process on a container or virtual machine” while consuming “an order of magnitude less memory” at startup. Kubernetes has no cold start in the serverless sense, because the pod was already running and you were already paying for it.

The operational burden nobody prices

The line items above exclude the expensive part. A Kubernetes cluster is a distribution you now maintain: version upgrades, CNI and CSI drivers, ingress controllers, admission policy, node image patching, cluster autoscaler tuning and a metrics stack. AWS puts a number on the cost of neglecting it: EKS extended support is $0.60 per cluster-hour rather than $0.10 once a version is more than 14 months past release, so staying a year behind turns a $73 monthly cluster fee into roughly $438.

The 2025 CNCF annual survey, published in January 2026, found 82% of container users running Kubernetes in production, up from 66% in 2023. The same survey found the barriers are organisational rather than technical: 47% named cultural change on the development team as the top challenge, 36% lack of training, 36% security concerns and 34% complexity.

“Over the past decade, Kubernetes has become the foundation of modern infrastructure.” — Jonathan Bryce, CNCF Executive Director, in the survey announcement.

Where each model genuinely wins

Serverless

Spiky or unpredictable traffic, event-driven glue, internal tools that idle at night, per-tenant workloads with wildly uneven load, and anything a small team wants to ship without owning a control plane. Below roughly 10 million monthly requests at modest memory settings, most functions cost less than lunch.

Kubernetes

Steady, high utilisation; heterogeneous workloads that benefit from bin-packing onto shared nodes; long-running processes and daemons; GPU scheduling; strict placement or affinity requirements; and organisations already running enough services that one platform team amortises across all of them. Kubernetes is a bin-packing and scheduling engine, and it earns its keep when you have things worth packing.

A plain virtual machine

This is the option that gets skipped, and it is frequently correct. If you have one to five services, a single region, predictable load, a managed database, and no requirement to schedule arbitrary workloads, two VMs behind a load balancer with systemd units and a deployment script will outrun both alternatives on cost and on the number of concepts a new hire must learn. Four DigitalOcean droplets at $192 a month replaced $650 of Autopilot in the example above. The honest cost is that you own patching, and you need a runbook for the day one instance dies.

How to run the numbers on your own service

Pull three figures from your existing monitoring before reading any vendor page: requests per month, mean CPU-seconds per request, and peak-to-mean concurrency ratio. Multiply the first two to get monthly CPU-seconds, divide by 2,628,000 to get sustained vCPUs, then price that both ways. If your peak-to-mean ratio is above about 5 and sustained utilisation is under a couple of vCPUs, serverless will almost certainly be cheaper. If the ratio is near 1 and you need more than roughly eight vCPUs around the clock, reserved capacity wins, and the remaining question is whether that capacity needs an orchestrator or just a machine. All prices quoted here are list prices retrieved in September 2026 and move with region, commitment discounts and negotiated agreements.

Sources

• Amazon Web Services — AWS Lambda Pricing
• Google Cloud — Cloud Run pricing
• Amazon Web Services — Amazon EKS Pricing
• Google Cloud — GKE pricing
• Cloudflare — Workers pricing
• AWS Documentation — Improving startup performance with Lambda SnapStart
• CNCF — 2025 Annual Cloud Native Survey announcement
• DigitalOcean — Droplet pricing