TUNE THE WHOLE STACK: .NET RUNTIME, CONTAINER, AUTOSCALING, NODES

.NET on Kubernetes
optimization

Akamas continuously analyzes your .NET workloads on Kubernetes. It sizes container resources, autoscaling policies, and the underlying nodes with the .NET runtime in view, so memory limits fit how the runtime actually uses them. The result is .NET services that run reliably, without OOMKills, at the lowest sustainable cost.

86

.NET WORKLOADS

−70

CPU CORES

−80 GiB

MEMORY

THE CHALLENGE

Three pain points every .NET team knows

The .NET runtime reads the container’s limits and sizes itself from them. Most teams set those limits without knowing that, and the cost shows up everywhere at once.

OOMKilled Pods and the Memory Beyond the Heap

By default, the .NET garbage collector caps its heap at a fixed share of the container memory limit. The rest is left for everything the GC can't see: native libraries, thread stacks, network and TLS buffers. When that native memory outgrows its share, the GC still reports a healthy heap while the pod climbs toward its limit. Then Kubernetes kills it.

Memory Pressure That Shows Up as CPU

A .NET service doesn't use more memory just because you give it more. But take too much away and the runtime fights back, collecting harder and more often to stay under the wall. The service slows down and burns CPU long before it runs out of memory, so the problem gets misread and fixed with the wrong resource.

Cloud Waste from Defensive Sizing

With no clear view of how much memory a .NET service really needs, teams pad memory limits for safety and copy them across services. CPU settings quietly change how much memory the runtime claims, too, so a tweak in one place shifts the other. The padding is paid for every month, on every replica.

HOW AKAMAS WORKS

Akamas optimizes .NET reliability and cost across the full stack.

The .NET application belongs to developers. Pods and HPA policies belong to platform teams. The runtime sits between them, reading limits one team sets to serve code the other team writes. When those layers are configured in isolation, the disconnect shows up as OOMKills, CPU spent fighting memory pressure, and padded limits that became the norm. Akamas continuously closes those gaps, with a single optimization view across the full stack.

DIAGNOSE

Find the misconfiguration before the OOMKill does

Akamas reads your live .NET workloads across three layers, from the observability data you already collect (Datadog, Dynatrace, Prometheus). No agents, no code changes:

  • The runtime: which workloads run on .NET, and how their memory use relates to the limits they run under.
  • The container: CPU and memory requests and limits, throttling, and OOMKill risk.
  • Autoscaling and nodes: HPA replica ranges, scaling targets, and the node groups underneath.

It ranks issues by what they cost you, not just resource flags. Each finding is categorized as efficiency, reliability, or best practice, and ties an observable behavior to its risk or its cost.

Memory running too close to the limit. A memory limit several times larger than the service ever uses. An HPA stuck at max replicas at every peak. The pattern behind the next outage is rarely in the obvious place. Akamas surfaces it where the data already lives.

ANALYZE

See how every layer
pushes on every other

.NET performance on Kubernetes is a set of interlocked dials. The memory limit sets how much heap the runtime allows itself, and how much room is left for native memory. CPU settings shift how many heaps the runtime creates, and how much memory it claims. Replica count shifts how much of that footprint gets multiplied across the cluster. Akamas plots these interactions against your live workload, so you see:

  • Allocated capacity versus real utilization across CPU and memory, for every .NET pod.
  • Where the memory limit leaves too little headroom for what the runtime needs beyond the heap.
  • Where limits sit so far above real usage that the padding is pure cost.

The decisions that were guesses become decisions backed by data.

Container tools see the pod, not the runtime inside it. Akamas sizes the pod knowing it runs .NET, against the workload that’s actually running.

OPTIMIZE

Recommendations that size Kubernetes for the .NET runtime

Akamas recommends specific changes across every layer of the stack: container CPU and memory requests and limits, HPA min and max replicas. Memory recommendations account for how the .NET runtime uses the limit it’s given, so the heap keeps its room and native memory keeps its headroom. Each recommendation shows expected impact on cost and reliability before anything is applied, including the risks it removes and any it could introduce. The data that drove each recommendation travels with it.

Engineering teams keep the call on what ships. Apply a change with a kubectl command, merge it as YAML into your GitOps flow, or let Akamas open a merge request in your repository. No code changes, only configuration. As traffic shifts, releases change memory profiles, or new services land, the recommendations adjust. The optimization isn’t a project. It’s how the system stays optimized.

Rightsizing a .NET pod without knowing it runs .NET moves the risk, it doesn’t remove it. Sizing the container for the runtime inside it, against the same workload, gives you a different curve.

.NET workloads change faster than configurations do. Akamas keeps the configuration moving with them.

How Akamas Compares

One view across .NET and Kubernetes

Kubernetes rightsizing tools size the container from its usage. Manual tuning depends on runtime expertise few teams have time for. Akamas sizes containers, autoscaling, and nodes with the .NET runtime in view, against the same reliability and cost targets.

Kubernetes rightsizing tools Manual .NET tuning Akamas
What it sees Container CPU and memory usage Runtime metrics, one service at a time Runtime, container, autoscaling, and nodes together
Accounts for how .NET uses the memory limit No Yes, by hand Yes
Keeps headroom for memory beyond the managed heap No Partial Yes
Tunes container resources and HPA Partial No Yes
Scales across hundreds of services Yes No Yes
Ties each change to cost and reliability impact Partial No Yes

POWERED BY CAPABILITY

Two capabilities, one optimization stack

Two ways to optimize the same .NET workload. Continuous optimization recommends changes from the observability data you already collect on your live production workload. Pre-production optimization searches the full configuration space in a test environment for the deepest tuning before you ship. Both keep every change reviewable before it goes live.

Continuous Optimization

Recommends runtime-aware container and HPA configurations on the observability data you already collect (Datadog, Dynatrace, Prometheus). Low friction, always on, grounded in production behavior.

Pre-production Optimization

Searches the full configuration space in a test environment, driven by your existing load tests, with no constraint on which runtime or Kubernetes parameters it tunes. The deepest optimization, before you ship. Extends beyond Kubernetes to .NET applications on virtual machines and traditional infrastructure.

FREQUENTLY ASKED QUESTIONS

Sizing the Kubernetes resources around a .NET application for how the .NET runtime actually behaves: container CPU and memory, autoscaling policies, and the nodes underneath. The payoff is .NET services that stop getting OOMKilled and stop paying for headroom they never use.
In one customer’s production environment, Akamas optimized 86 .NET workloads on Kubernetes, freeing 70 CPU cores and 80 GiB of memory. The savings come from sizing containers for the .NET runtime inside them, not from cutting resources blindly.
Because the garbage collector only manages part of the process memory. By default, .NET caps its heap at a share of the container memory limit and leaves the rest for native memory: libraries, thread stacks, network buffers. If that native memory outgrows its share, the pod crosses the container limit while the heap still looks fine. Akamas sizes the memory limit with that headroom in view.
When memory gets tight, the .NET runtime doesn’t simply fail. It collects garbage harder and more often to stay under the limit, which costs CPU and adds latency. That’s why memory pressure on .NET often looks like a CPU problem first. Akamas reads memory and CPU together, so the fix targets the right resource.
No. The gains come from configuration, not code. Akamas reads the metrics your observability tools already collect, with no agents, and recommends Kubernetes settings from observed workload behavior.
It depends on the approach, and either way Akamas doesn’t change production on its own. Continuous optimization recommends changes and shows their expected impact; your team reviews and decides what ships, with kubectl, YAML, or a merge request. Pre-production optimization automatically finds the best configuration in a test environment, and you then choose whether to promote it to production. The decision to change production is always yours.

Akamas named a Leader in the GigaOm Radar for Cloud Resource Optimization v5, 2026
Akamas named an Outperformer in the GigaOm Radar for Cloud Resource Optimization v5, 2026

See for Yourself

Experience the benefits of Akamas autonomous optimization.
No overselling, no strings attached, no commitments.