Kubernetes optimization is easier said than done. The reality we keep finding in the wild is that clusters are massively over-provisioned, with average CPU usage at 5% or less. Those same applications still carry real reliability risk, and some are already having incidents. Over-provisioned and fragile at the same time.
Akamas Insights closes that gap. Insights analyzes your whole Kubernetes environment. It detects optimization opportunities across clusters, pods and application runtimes. It estimates the savings behind each one. It then recommends configuration changes you can apply safely, covering pod resources, HPA scaling policies, and runtime settings for the JVM and Node.js. Insights runs agentless, on metrics your monitoring stack already collects.
We built Akamas Insights for developers, SREs, DevOps and FinOps teams who need optimization results without becoming full-time optimization specialists.
Why Kubernetes optimization stalls
The promise of self-healing, efficient cloud-native applications is still not realized. After years of working with Kubernetes teams, we see two root causes. One is technical: Kubernetes resource management is genuinely hard. The other is organizational: the teams who could act on optimization are not the teams who own it.
The technical problem: pod resources, autoscaling and runtimes
Kubernetes resource management is difficult to reason about. How do you set pod requests, limits and horizontal scaling so that hundreds of microservices stay both reliable and efficient? Nobody does that by hand at scale.
Application runtimes make it harder. The JVM and Node.js V8 both size their memory from what the container exposes, not from what the application actually needs. The results are familiar: OOMKilled pods, CPU throttling, heap far larger than the workload uses, and slowdowns nobody can explain. We collected the ones we hit most often in 10 Kubernetes performance pitfalls.
The organizational problem: everyone owns a piece, nobody owns the outcome
Even when the technical answer is known, optimization work stalls. The reason is structural:
- Platform teams run the clusters, but they cannot change application configuration.
- Development teams own the applications, and they are measured on shipping features.
- DevOps and SRE teams get handed optimization on top of automation work and incident response.
- Performance engineers have the expertise, but they struggle to get time from teams with no test environment and competing priorities.
Everyone owns a piece of the problem. Nobody owns the outcome. There must be a better way.
What Akamas Insights does
Akamas Insights analyzes your entire Kubernetes environment and produces three things:
- Visibility. Every optimization opportunity across all your clusters, in one place.
- Impact. The estimated effect of each opportunity, including achievable savings.
- Recommendations. Prioritized, safe configuration changes for both infrastructure and applications.
Setup requires no skills and no agents. Insights reads the metrics your Kubernetes observability tools already collect, so nothing new runs inside your workloads.
Automatic detection of Kubernetes optimization opportunities
Insights sorts what it finds into three categories. The point of splitting them is that different teams act on different categories.
| Category | What Insights looks for | Example finding |
|---|---|---|
| Efficiency | Ways to cut resource usage and cost | Inefficient cluster autoscaling; heap memory far larger than the application uses |
| Reliability | Risks that can cause a production incident | JVM heap misaligned with the pod memory limit; HPA settings that cannot absorb a traffic peak |
| Compliance | Workloads that break your own best practices | Memory limits not equal to memory requests; JVMs running on default or inadequate options |
Efficiency opportunities are where the cost savings sit. Insights looks at three layers to find them: clusters, workload pods, and application runtimes such as the JVM and Node.js V8. Analyzing all three together is what surfaces the bigger wins, including inefficient cluster autoscaling and memory wasted on over-provisioned heap.
Reliability matters more than cost to most SRE and development teams, so Insights detects reliability risks before they reach production. A workload whose JVM heap does not fit inside its memory limit is one example. Misconfigured HPA settings that stop an application absorbing traffic peaks are another.
Platform engineers get a third angle: preconfigured best-practice checks. Examples include memory limits that differ from memory requests, and JVMs still running on defaults.
Insights ships with 50+ preconfigured optimization opportunities across the full Kubernetes stack. We curated them from optimizing 1000s of Kubernetes clusters. (Source: Akamas field data from customer and prospect Kubernetes environments.) That is well beyond the scope of tools that look at pod resources alone.
Estimated savings across infrastructure and application workloads
An opportunity nobody can quantify does not get prioritized. So Insights estimates the impact of every opportunity it detects, and it ships that estimate with the finding rather than after it.
Insights estimates the resource footprint and the achievable savings, then splits the estimate two ways: infrastructure and application workloads. You can see the value of optimizing the workloads, the clusters, or both. In an organization where every team is already oversubscribed, showing an engineer the concrete benefit is what turns an optimization backlog into optimization work.
Application-aware recommendations you can apply safely
When we talk to Kubernetes teams, one theme comes up repeatedly: engineers are reluctant to optimize their applications. That is When we talk to Kubernetes teams, one theme comes up repeatedly: engineers are reluctant to optimize their applications. That is not stubbornness. They are the ones paged when reliability or performance breaks.
Most Kubernetes resource optimization tools do nothing about that fear, because they only consider the container and ignore the application running inside it. Applications do not run on Kubernetes directly; they run on a language runtime that most tools never look at. Insights recommends changes across the full application stack:
- Pod CPU and memory requests and limits
- HPA scaling policies and thresholds
- JVM heap and garbage collection settings for Java workloads, tuned together with the Kubernetes memory limits around them
- V8 memory settings for Node.js workloads
| What gets tuned | Typical pod rightsizing tool | Akamas Insights |
|---|---|---|
| Pod CPU and memory requests and limits | Yes | Yes |
| HPA scaling policies | Varies by tool | Yes |
| Cluster and node-level waste | Varies by tool | Yes |
| JVM heap and garbage collection settings | No | Yes |
| Node.js V8 memory settings | No | Yes |
| Reliability risks alongside cost | Varies by tool | Yes |
The difference is not academic. At Sisal the money was in the JVM, not in the container. Oversized JVM memory was the largest single source of waste. Correcting it cut the cost of critical microservices by 58%. A tool that stops at the container boundary cannot see that. The same argument applies to Node.js. In our own benchmarks, tuning the V8 heap pools cut application latency by almost 50%, with no code changes.
What this looks like in production
Sisal, a gaming operator serving 35 million customers, cut the cost of critical Kubernetes microservices by 58%. It took two weeks of live optimization, and the biggest lever was oversized JVM memory rather than container sizing. Akamas tuned pod sizing, JVM heap and the garbage collector together. The details are in the Sisal case study.
How to get started with Akamas Insights
Insights is quick to set up. You install no agents, so nothing new runs inside your workloads. Insights collects metrics from the Insights is quick to set up. You install no agents, so nothing new runs inside your workloads. Insights collects metrics from the Kubernetes observability tools you already run, and it integrates with your existing monitoring stack, including Prometheus, Datadog and Dynatrace. It needs a read-only account to start analyzing your environment.
Two ways to start:
- Estimate what you are wasting with the Kubernetes waste calculator.
- Create an account and run Insights against your own clusters.
Cloud-native optimization should be accessible, safe and effective for every team, not only for specialists.
FAQs
What is Akamas Insights?
Akamas Insights is a Kubernetes optimization capability that analyzes clusters, pods and application runtimes. It detects optimization opportunities, estimates the savings behind each one, and recommends safe configuration changes. Coverage includes pod resources, HPA scaling policies, and JVM and Node.js runtime settings.
Does Akamas Insights need agents in my cluster?
No. Insights is agentless. It reads metrics that your Kubernetes observability stack already collects, such as Prometheus, Datadog or Dynatrace, and it needs a read-only account. Nothing runs inside your workloads, so setup does not touch application code or pod specs.
How is Akamas Insights different from pod rightsizing tools?
Pod rightsizing tools size the container. Insights also tunes what runs inside it. It covers pod requests and limits, HPA policies, cluster-level waste, and runtime settings such as JVM heap, garbage collection and V8 memory. Container sizing alone leaves both savings and reliability risks untouched.
Which application runtimes does Akamas Insights optimize?
Insights analyzes the JVM for Java workloads and V8 for Node.js workloads. It examines heap sizing, garbage collection settings and memory configuration, then checks them against the pod resources around them. A JVM heap that does not fit inside its pod memory limit is one of the most common findings.
Are the recommendations safe to apply in production?
Insights accounts for the application, not only the container, which is what makes a recommendation safe to apply. Every recommendation arrives prioritized and with its estimated impact, so you can review it first. Insights recommends; you decide what lands and when.
