Resource Topic: Kubernetes

  • Performance-aware instance recommendations: pricing a vCPU by the work it does

    Performance-aware instance recommendations: pricing a vCPU by the work it does

    When you pick an instance type for a Kubernetes node group, the comparison usually comes down to three numbers: vCPUs, memory and hourly price. Two instance types with the same vCPU count look interchangeable, so the cheaper one wins. That logic has a blind spot. A vCPU is not always a core: depending on the instance family, it is either one hardware thread or a whole physical core. A vCPU on a recent processor can also do far more work than one a few generations older, and the gap shows up directly in how much CPU your workloads consume.

    Akamas Vivo now accounts for that gap. Its node group recommendations for kubernetes clusters include a performance-aware cost for every candidate instance type, an estimate of what the node group would cost once your workloads’ CPU reservations are adjusted to the speed of the new hardware. The cheapest instance on the price list and the cheapest way to run your workloads are often two different instances, and this feature shows you both side by side.

    In this post we explain why a vCPU is a poor unit of comparison, how the Performance Index behind the feature is built, and how it turns into a cost. We also show what it found on the largest node group of a customer’s production cluster. There, the best option was an EC2 instance that costs 60% more per hour and still cuts the bill by 23%.

    vCPU vs core: why one vCPU is worth more than another

    Kubernetes measures CPU in units where one CPU equals one physical or virtual core, and it accounts for CPU as time: a container that keeps a core busy for half of every second is using 500 millicores. This model is simple and works well within a single type of machine. Across machine types, it hides an important detail. If a newer core completes the same request in half the time, the same workload uses half the millicores, even though nothing in the application has changed.

    The differences between cores on a cloud provider are large, and they come from more than clock speed. Each processor generation brings better microarchitecture, larger caches and faster memory. The meaning of a vCPU also changes from one family to the next. On many AWS instance families a vCPU is one hardware thread of a core shared with another thread through simultaneous multithreading (SMT). On others it is a whole physical core. AWS states, for example, that every vCPU on an M7a instance is a physical CPU core, while on the previous M6a generation each vCPU is a thread of a core, and the same holds for the newer M8a family. Two instances with “4 vCPUs” on the label can therefore offer quite different amounts of real compute.

    Until now, Akamas Vivo treated every vCPU as equal when it compared instance types, as most instance price comparisons do. A node group recommendation looked for the cheapest machines able to hold the CPU and memory your pods request, and a vCPU was simply a vCPU. That approach systematically undervalues newer and faster hardware: a faster instance usually costs more per hour, and a comparison that ignores its speed only sees the higher price.

    Measuring the work a core can do

    To compare cores fairly you need a common yardstick, and the feature uses one of the most widely adopted CPU benchmarks, CoreMark. Developed by the EEMBC consortium in 2009 as a replacement for the older Dhrystone benchmark, CoreMark runs a fixed mix of list processing, matrix manipulation, a state machine and CRC checks, and reports a single number: how many iterations of that work a processor completes per second. Higher is better, and because the benchmark is small, portable and self-checking, its scores are available for a very wide range of processors, including the processors behind AWS instance types.

    From these scores Akamas Vivo derives a Performance Index for every candidate instance type, defined as the estimated work done per CPU core by the candidate relative to your current instance type. It reads as a multiplier: 1.20x means each core of the candidate is estimated to do 20% more work than a core you run today, 0.85x means it is 15% slower, and 1.00x means parity. Where benchmark data is missing, Vivo uses published generation-over-generation figures from the CPU vendors.

    This is an empirical model, and we prefer to say so clearly. A benchmark score is an average over a specific set of operations, and no single number can describe how every application will behave on a new processor. A memory-bound service gains less from a faster core than a compute-bound one, and a workload that relies on instructions the benchmark does not exercise can move in either direction. What the index offers is a well-founded estimate of the typical difference between two kinds of hardware, which is far closer to reality than the implicit assumption that every vCPU performs the same.

    From faster cores to fewer nodes

    A faster core reduces the CPU your workloads use, but your cloud bill depends on the CPU they request. The scheduler places pods according to their requests, and the cluster autoscaler or Karpenter adds nodes until every request fits, so the number of nodes you pay for follows the requests. Moving the same pods to faster hardware lowers their usage while their requests stay exactly where they were, and on its own that saves nothing.

    The saving appears once something brings the requests down to match. That something can be a right-sizing process, whether it is a team applying recommendations or a tool like Akamas Vivo doing it automatically, or a Horizontal Pod Autoscaler that runs fewer replicas because each one now handles more traffic. Take a workload that requests 2.2 cores and uses 1.9. On cores that do twice the work, it will use about 0.95. If its requests are right-sized to keep the same ratio between usage and request, they drop from 2.2 to 1.1 cores, and across a whole node group that roughly halves the CPU the nodes need to provide.

    The performance-aware cost applies this reasoning to the whole node group. For each candidate instance type, Akamas Vivo divides the CPU requests of the workloads in the group by the candidate’s Performance Index, leaves memory requests unchanged, and simulates how many nodes of that type the group would need. Multiplying by the hourly price gives a monthly cost that can be compared directly with the ordinary cost column. A candidate that costs a third more per hour but does twice the work per core needs about half the nodes, so the group ends up roughly a third cheaper, a result that a plain price comparison would never show.

    Five-step flow: 2.0x faster cores cut CPU use from 1.9 to 0.95 cores, requests drop from 2.2 to 1.1, nodes halve, cost falls about 33%

    The estimate is optimistic by design. As the documentation puts it, it assumes every workload’s CPU reservation is eventually right-sized to the new hardware, because it measures the full potential of the instance type. Choosing an instance type is a hardware decision, and its score should not depend on how well tuned your workloads happen to be today.

    How it shows up in Akamas Vivo

    The feature lives in the Node Groups recommendations of each cluster, for node groups managed by the Kubernetes Cluster Autoscaler or by Karpenter. For every node group, an Instance Comparison table lists up to ten instance types, chosen to answer three different questions at once:

    • your current instance type, the reference for every other row;
    • the three cheapest alternatives, which minimize the bill against the CPU your workloads reserve today;
    • the three with the lowest performance-aware cost, which minimize it against the work your workloads actually do;
    • the three fastest per core, regardless of cost, for teams that need raw performance.

    On AWS clusters the table adds two columns, Performance Index and Performance-Aware Cost, next to the ordinary monthly cost, and both cost columns show the change against what you pay today in percent and in dollars. Badges point out the rows that matter: Best cost marks the cheapest instance type, Best price performance marks the lowest performance-aware cost, and Best performance marks the highest Performance Index. The best price performance row is often a different instance from the cheapest one, since a faster instance can do the same work on fewer nodes. When the two coincide, the same row carries both badges.

    Two safeguards keep the recommendations practical. Instance types are compared within the same CPU architecture, so an x86 node group is never told to move to ARM-based Graviton instances, a change that would require rebuilding and validating every container image. And a filter called Exclude slower instance types, off by default, removes every candidate whose cores are slower than the hardware you run today, for teams that do not want to trade speed for price.

    Akamas Vivo recommendation filters for a node group, with the Exclude slower instance types toggle off by default

    The feature also changes the shape of the machines it recommends, and this is worth understanding before you act on it. Only CPU requests are rescaled by the Performance Index, while memory requests stay exactly as they are. Once a node group needs much less CPU for the same memory, the best fit moves toward instance families with more memory per vCPU. For example, on AWS that could mean moving from general-purpose M instances, with 4 GiB of memory per vCPU, to memory-optimized R instances, with 8 GiB per vCPU.

    Today the performance data covers AWS instance types only. On Azure, Google Cloud and OCI clusters the two performance columns are hidden and the table falls back to the cheapest alternatives.

    A real example: the largest node group of a production cluster

    To see what the feature finds in practice, we looked at one of our customers, a company that runs several dozen Kubernetes clusters on AWS. We picked the largest node group of its main production cluster, which runs on general-purpose M instances and scales automatically to an average of about 139 nodes. Its workloads were well sized, with CPU and memory requested in roughly the 1 to 4 ratio that M instances are built for.

    The table below summarizes three of the candidates Akamas Vivo compared for this node group.

    CandidatePerformance IndexChange in costChange in performance-aware cost
    Newer-generation R instance (Best price performance)2.10x+60%-23%
    Slightly slower instance0.95x-14%about -10%
    Older-generation instance0.61x-13%+42%

    The first row is the interesting one. On the price list, moving this node group to the recommended instance type looks like a mistake, since each node costs about 60% more and a plain comparison would report a 60% increase in the bill. Once the speed of its cores is taken into account, the picture reverses: the workloads need so much less CPU that far fewer nodes are required, and the node group would cost 23% less than today, about 11K dollars per month for this node group alone. The recommendation also switches from an M to an R family, exactly the shape change described above, because the memory requests stay the same while the CPU requests shrink.

    The other two rows show the opposite effect. An instance whose cores are 5% slower but 14% cheaper per hour still comes out ahead, at roughly 10% less, since the lower price more than compensates for the small loss in speed. An older-generation instance that looks 13% cheaper on the price list turns out to be a poor deal: its cores do so much less work that the node group would need about 42% more resources to run the same workloads. Without the Performance Index, this last instance would have looked like a saving.

    Akamas Vivo Instance Comparison table: r8a.4xlarge costs 60% more than m7i.2xlarge but has 23% lower performance-aware cost

    What to keep in mind before you switch

    The performance-aware cost describes what an instance type can deliver, and turning that potential into a smaller bill depends on a few conditions in your cluster.

    The saving only materializes when CPU requests follow the lower usage. Workloads that are right-sized regularly, by a team or by a tool like Akamas Vivo, and services scaled by an HPA will adapt. Workloads with fixed requests that nobody revisits, or services that already sit at their minimum number of replicas, will keep reserving the same CPU on the new nodes, and the node group will not shrink as much as the estimate suggests. The freed capacity also has to be reclaimed, which is the job of the Cluster Autoscaler or Karpenter once requests go down.

    The Performance Index is an average. Your services may gain more or less than the benchmark predicts, depending on how much they rely on the CPU compared with memory, network or storage.

    Finally, keep an eye on memory. Because only CPU is rescaled, the recommended instance types often have more memory per vCPU than the ones you run today. That is the correct outcome for a cluster whose CPU needs shrink, but it changes how much headroom you have if memory demand grows, so it is worth reviewing your memory requests together with the new node shape.

    Price the work, then choose the hardware

    The hourly price of an instance tells you what a vCPU costs, while the Performance Index tells you how much work that vCPU does. Putting the two together changes which instance types look attractive: newer generations that seem expensive often turn out to be the cheapest way to run your workloads, and older ones that seem like a bargain can end up costing more. On the node group we examined, the difference between the two views was a 60% increase on paper against a 23% saving in practice.

    Performance-aware costs are available today in the Node Groups recommendations of Akamas Vivo for clusters running on AWS. Vivo reads the metrics your monitoring stack already collects, so you can see the Performance Index and the performance-aware cost of your own node groups within hours of connecting a cluster. Start a free trial, read how it works in the documentation, or book a demo with one of our engineers.

    Mario Scriminaci is Product Director at Akamas, the autonomous optimization platform for Kubernetes and AI infrastructure. He works on how teams get more out of the GPUs they run.

  • The Michelin Star Dilemma and the Secret to a Perfect Service

    The Michelin Star Dilemma and the Secret to a Perfect Service

    In the world of fine dining, the tension in the kitchen is palpable long before the first guest arrives. Imagine a prestigious Michelin-starred restaurant where the night’s success depends on four formidable characters who rarely see eye-to-eye. There is the Owner, who meticulously tracks the cost of every truffle and the electricity bill of the walk-in freezer; there is the Executive Chef, who would rather throw away ten gallons of perfectly good consommé than risk serving a single plate that is less than transcendent; there is the restaurant manager, who struggles to coordinate the chaotic flow between the ovens and tables using a reservation system that feels increasingly outdated; and finally, there are the Line Cooks, the ones actually preparing the dishes.

    If the Owner cuts the budget too thin, the quality of the food collapses. If the Chef over-prepares to ensure they never run out of ingredients, the restaurant bleeds money through food waste. If the Manager fails to sync the two, the entire experience becomes a slow-motion disaster. The Line Cooks are caught in the middle: they want to innovate and serve great food, but they lack the data to know if they are using too many expensive ingredients or if their “stove” is set to the right temperature.

    In the digital landscape of cloud-native enterprises, our Kubernetes clusters are the kitchens, and our microservices are the delicate dishes being served to millions of hungry users. The FinOps team acts as the Owner, scrutinizing the cloud bill and demanding that we stop paying for “tables” that sit empty during off-peak hours. The Site Reliability Engineers (SREs) are our Chefs, their reputation is built on uptime and performance, and for them, an over-provisioned cluster is not waste: it is the extra pantry stock that prevents a catastrophic “sold out” sign during a traffic surge. Meanwhile, the Platform Team is the Manager, trying to build a standardized infrastructure that keeps the peace while the tickets pile up. In this scenario, the Developers are the Line Cooks creating the recipes: without clear guidance, they end up requesting more fridge space than necessary, fearing that the Chef (SRE) or the Owner (FinOps) will take away the “heat” they need to finish the service. This is the real problem behind Kubernetes cost management: it is rarely a budgeting exercise, and almost always a coordination one.

    The Invisible Wall

    This structural gap is what we call the Invisible Wall. It is a byproduct of specialization where everyone is doing their job perfectly, yet the organization as a whole is failing to achieve true efficiency.

    According to the 2026 FinOps Foundation’s State of FinOps report, the primary challenge for organizations has shifted toward reducing waste and over-provisioning while still struggling with “empowering engineers to take action”.

    This isn’t because engineers are lazy; it is because the Merchant, the Chef and the Line Cooks speak different languages. When a FinOps spreadsheet says a pod is 80% idle, the SRE hears a threat to their reliability buffer, while Developers simply lack the data to know how much space their specific application actually requires. Without a shared source of truth that translates “dollars saved” into “risk managed”, these teams remain locked in a cycle of conservative over-provisioning and reactive cost-cutting.

    Diagram showing how FinOps, SRE, developer, and platform teams' conflicting priorities lead to over-provisioning and friction in Kubernetes cost management

    The tragedy of this friction is that it treats optimization as a zero-sum game, a world where you must choose between a healthy bottom line and a reliable service. Ironically, this defensive over-provisioning doesn’t just inflate the bill; it often results in suboptimal performance and reliability issues, such as unexpected Out-Of-Memory (OOM) errors, as teams lack the precision to balance resources correctly. The reality of modern cloud-native architecture is far more nuanced. True efficiency is not about buying cheaper ingredients: it is about the fit of the resource to the task. That is the very principle on which Akamas Insights was born.

    To achieve adequate fit for purpose, Akamas Insights introduces the concept of the Tuning Profiles. Think of it as the “House Rules” or the “Recipe Standard” for the kitchen. A Tuning Profile allows the Platform Team and the SREs to define the boundaries of optimization, specifying which objective matters most (such as cost reduction or latency improvement) and which constraints must be respected (such as minimum replicas or memory headroom). By establishing these profiles, the Chef (SRE) can trust that the Owner’s demands will never violate the fundamental safety limits of the service. This is what turns Kubernetes cost management from a tug-of-war into a shared, governed practice.

    Diagram showing how Akamas Insights aligns FinOps, SRE, and platform teams around a shared view to achieve high reliability and low waste in Kubernetes

    The Full-Stack Recipe for Kubernetes Cost Management

    Instead of looking at a Kubernetes cluster as a collection of static boxes, Akamas Insights treats the environment as a living, breathing organism. By bridging the gap between infrastructure metrics and application runtime behavior, it allows the Owner, the Chef, the Manager, and the Line Cooks to finally look at the same dashboard and see the same truth.

    When we talk about deep, full-stack optimization, we are looking at the vertical stack of dependencies. Optimization is a multi-layered puzzle. It starts at the Application Runtime (tuning JVM heap or Go GC) to ensure the engine is healthy. Only then do we move to the Pods, sizing requests and limits to perfectly encase that runtime. Crucially, this is where we also align the Horizontal Pod Autoscaler (HPA). If an HPA scales on a metric that doesn’t align with the Pod’s new limits, the system will “flap” and become unstable. Akamas Insights coordinates these layers so that when we increase density, the contents still have room to breathe.

    Finally, we size the Node Group accordingly, ensuring the underlying hardware is the right vessel for these optimized and correctly-scaled containers. By following this sequence, the infrastructure becomes a direct reflection of the application’s actual needs, rather than a collection of oversized safety nets. Effective Kubernetes cost management lives in this coordination across layers, not in any single rightsizing step.

    Three-layer model showing how full-stack Kubernetes optimization spans App Runtime (JVM, concurrency), Pods and HPA (CPU, memory, scaling), and Node Groups to achieve optimal density

    Action over Analysis

    This level of insight transforms the conversation from one of cutting to one of tuning. In our restaurant metaphor, this is the equivalent of a smart inventory system that knows exactly how many guests are coming, their dietary preferences, and the precise temperature each oven needs to be to minimize energy without losing a degree of heat. When the Platform Team can present an optimization plan backed by a verified Tuning Profile that accounts for JVM heap settings, CPU cores, and node affinity, the SRE no longer feels the need to hoard resources “just in case”. They can see, through data-driven and historical analysis, that the new configuration is actually more stable than the old, bloated one.

    Furthermore, the industry is beginning to realize that the “Spring Cleaning” approach to cloud costs is fundamentally broken. You cannot achieve a Michelin star by cleaning your kitchen once a year: it requires constant, meticulous attention to detail. Yet, many organizations still treat FinOps as a quarterly audit and a reactive “Crawl” stage behavior. According to the FinOps Foundation’s Workload Optimization capability, true maturity (the “Run” stage) is defined by a shift toward Continuous Optimization.

    However, the path to this maturity is not about handing the keys of the kitchen over to an unpredictable autonomous agent. In a world where reliability is paramount, a “black-box” real-time approach can introduce more instability and “flapping” than it solves. True excellence requires a Human-in-the-Loop model where the Developers (the Line Cooks) are the essential piece. Instead of chasing every micro-fluctuation, the most effective optimization happens in lockstep with the release cycle.

    Workflow diagram showing the continuous optimization cycle with Akamas Insights: deploy, analyze telemetry, generate AI-powered recommendations, human review, and apply to next release

    Every time a new version of the “menu” is released, Akamas Insights performs a deep analysis of the previous cycle’s telemetry. It then generates intelligent, evidence-based recommendations tailored to the Tuning Profile. These recommendations are presented to the Developers for review. This is the “aha!” moment: the developer sees exactly how their code performs and can approve the new configuration with one click, knowing it aligns with the safety standards set by the SRE. This ensures that resource efficiency is balanced against performance and reliability within a controlled, predictable workflow: Release, Analyze, Recommend, and Apply. By connecting directly to the telemetry data teams already have, Akamas Insights turns the release cycle into a self-improving loop of continuous harmony.

    The Michelin Standard of Engineering

    This transition allows the Platform Team to fulfill its true potential. Instead of being the “Manager” who spends all night mediating between the “Owner” and the “Chef”, they become the architects of a system that empowers Developers to be efficient by default. This creates a culture of “Unit Economics”, where the cost of a transaction is as much a part of the performance metric as latency or error rate. When everyone understands that a 10-millisecond improvement in code efficiency translates directly to a specific reduction in the cloud bill, the silos finally begin to crumble.

    The beauty of this harmony is that it liberates the human talent within the organization. Engineers who used to spend their weeks manually tweaking YAML files and arguing over resource limits are suddenly free to innovate. The FinOps team moves from being the “budget police” to being strategic advisors who can predict how a new product launch will impact the bottom line with surgical precision. The SREs can sleep through the night, knowing their clusters are not just “big enough”, but “accurate enough”.

    As we look toward the future of cloud-native technology, the goal is no longer just “getting to the cloud”. We are already there. The goal is to live in the cloud with grace and precision. We must move beyond the blunt instruments of the past and embrace a more sophisticated way of managing our digital kitchens. The “Michelin Star” of engineering is awarded to those who can deliver a flawless user experience with the elegance of a perfectly managed budget. By using intelligent, full-stack insights to bridge the gap between our teams, we stop guessing, stop wasting, and finally start cooking with fire.

    FAQs

    How can FinOps and SRE teams agree on Kubernetes cost management?

    They agree when cost and reliability stop being separate conversations. A shared Tuning Profile sets the objective (such as cost reduction) and the hard constraints (such as minimum replicas or memory headroom) up front. FinOps gets savings, SREs keep their safety limits, and both work from the same data.

    What is the most effective way to manage Kubernetes costs without hurting reliability?

    Optimize the full stack in order: application runtime first, then pods and HPA, then the node group. Each layer is sized to the layer above it. This keeps reliability headroom intact while removing the over-provisioning that pure pod rightsizing leaves behind.

    How do you enforce cost accountability in Kubernetes?

    Tie cost to the release cycle instead of treating it as a quarterly audit. When every release is analyzed and developers approve resource changes with full visibility, cost becomes a unit-economics metric owned by the team that ships the code, not a bill reviewed after the fact.

    Why do SRE teams over-provision Kubernetes resources?

    Over-provisioning is a reliability buffer. Without data showing that a smaller configuration is stable, an idle pod looks like insurance against a traffic surge. The fix is evidence: historical analysis that proves the tuned configuration is more stable than the bloated one.

    How is continuous optimization different from quarterly cost-cutting?

    Quarterly cost-cutting is reactive and coarse, like cleaning a kitchen once before an inspection. Continuous optimization runs with each release, applying small, validated adjustments through a Release, Analyze, Recommend, and Apply loop. It holds efficiency steady instead of letting waste accumulate between audits.

  • The State of Cloud Native Optimization 2026

    The State of Cloud Native Optimization 2026

    A critical realization has emerged within the platform engineering community. We have excelled at creating golden paths that streamline the developer experience, yet we have largely neglected the lifecycle of applications once they reach production. We built robust pipelines, extensive automation, and reusable services that let developers ship software fast. A significant gap remains in our operational maturity.

    This is the state of cloud native optimization in 2026. Akamas interviewed more than 50 enterprises to measure the Day 2 operations gap. The finding is stark. 72.6% of organizations still tune Kubernetes manually. Only 18% optimize the container and its runtime together. And 52% rely on a shared ownership model where no single team acts decisively.

    Today, our main way of helping developers after deployment is handing them monitoring dashboards. We have not built the automated processes that would help them actively tune applications against real-world demand. That missing link between deployment and continuous operational efficiency is where the next evolution of cloud-native infrastructure must focus.

    The Ownership Dilemma: Who Owns Cloud Native Optimization?

    To size the challenge, we ran in-depth interviews with over 50 organizations across telecommunications, healthcare, finance, defense, and insurance. (Source: Akamas 2026 State of Cloud Native Optimization survey; 50+ enterprises across those sectors.)

    Geographic distribution of surveyed enterprises: about 70% in Europe and 21.9% in the United States

    The geographic distribution shows that almost 70% of these enterprises are based in Europe, while 21.9% operate in the United States. By scale, 38.3% are Large organizations and 25.5% are Enterprise-scale entities.

    Team structure across surveyed organizations: dedicated platform teams present in about 43%

    A close look at how these companies organize their technical teams reveals a fragmented picture. Dedicated platform teams are present in roughly 43% of organizations. Companies without them often patch their platforms with disjointed efforts and shallow automation that never covers the full developer workflow.

    Site Reliability Engineering and FinOps present an even larger organizational challenge. SREs frequently operate in silos inside individual application teams, with no standardized reliability baseline across the company. Dedicated FinOps teams exist in only about 20% of organizations. For many, financial optimization is outsourced or treated as a quarterly, reactive cost-cutting exercise rather than a continuous discipline.

    This fragmentation raises a basic question of accountability: who actually owns the optimization process?

    Kubernetes optimization ownership model: 52% of organizations use shared ownership across teams

    The data shows that a shared ownership model dominates, at 52% of organizations. Shared responsibility sounds healthy in theory. In practice, when everyone is responsible, nobody acts.

    The paralysis comes from conflicting priorities. Developers are measured on shipping features and have no time to revisit legacy deployments. SREs prioritize stability and overprovision resources to buffer against traffic spikes and costly outages. FinOps sees that same overprovisioning as waste and pushes to cut the cloud bill. The developer stays trapped in the middle of this structural conflict.

    The Cost vs Performance Trade-Off in Kubernetes

    These internal frictions map cleanly onto the pain points reported at the organizational level.

    Top cloud-native pain points: 38.6% cite cost and 36.1% cite performance

    Companies split almost evenly between optimizing for cost and maximizing performance: cost concerns are cited by 38.6% of respondents and performance by 36.1%. Organizations want highly performant applications while holding strict cost controls and guaranteeing reliability.

    That trade-off is exactly why static golden paths fail at Day 2. When building deployment pipelines, everyone shares one goal: release software. That allows strict, opinionated automation. Production optimization is different. Each application needs dynamic tuning shaped by its own risk profile, tech stack, and performance needs.

    Kubernetes adoption: 74.5% of surveyed organizations run Kubernetes as their baseline

    Examining the technology stack, Kubernetes is the industry baseline. It runs in 74.5% of organizations. For the runtimes inside those clusters, the JVM dominates. It powers 53.1% of workloads. .NET follows at 18.4% and Python at 10.2%.

    Understanding the runtime matters because infrastructure optimization is a layered problem. You cannot optimize a system while treating the container as an opaque black box. Yet only 18% of companies tune the container and its runtime together.

    Full-stack tuning gap: only 18% of organizations tune the container and its runtime together

    On Kubernetes, full-stack visibility is not a nice-to-have. It is the only way to realize ROI. Organizations tend to fall into one of two traps:

    1. The Bottom-Up Failure. They optimize the node and cluster layer, but individual workloads stay poorly rightsized. The result: inefficient applications running on cheaper hardware, still paying for “ghost” resources that add no value.
    2. The Top-Down Failure. They “rightsize” pods by cutting limits but never touch the cluster configuration. The result: the cloud bill holds flat because nodes stay underutilized, and the provider still charges for the full instance.
    Application runtime distribution on Kubernetes: JVM 53.1%, .NET 18.4%, Python 10.2%

    The first layer is the container limits, which are relatively simple to adjust. The second layer, the application runtime, is where real efficiency is won or lost. Allocate a large container but run a JVM with default settings, and the runtime may use only a fraction of the available memory, wasting the rest. Misaligned settings do the opposite: they trigger fatal out-of-memory errors when the runtime reaches past the container’s physical boundary. This is the failure mode we cover in depth in JVM on Kubernetes optimization.

    The next layer is the Horizontal Pod Autoscaler. Teams often treat horizontal scaling as a universal remedy, but applying it to misconfigured pods only multiplies the underlying inefficiency. For JVM applications, our analysis shows that giving more resources to a single, properly tuned pod often beats scaling out with many small, inefficient pods on latency and throughput. The node layer is where the largest cost savings live, but only once the pod and scaling layers are optimized to maximize cluster density and accurate bin packing.

    Moving Beyond Manual Tuning

    Faced with these layers, organizations want a way out of manual tuning. Our research shows most are stuck in an operational no-man’s-land.

    Optimization maturity: 72.6% tune Kubernetes manually and 17.6% work reactively

    The maturity gap is two-dimensional:

    • Method: 72.6% of companies manage optimization entirely manually, relying on engineers to adjust limits and parameters by hand.
    • Mindset: 17.6% remain in a purely reactive “firefighting” mode, touching configurations only after a performance degradation or an OOM error.

    Even proactive teams often stay manual, spending hundreds of engineering hours on trial-and-error tuning. That approach does not scale. Human intuition cannot keep pace with the fluctuating demand of a cloud-native environment. The shift has to move from best-guess adjustments toward a deterministic model.

    Effective optimization needs a system that does not just suggest changes. It calculates them from precise, mathematical resource configurations. Remove the guesswork, and teams can set safe, reliable scaling boundaries that protect production workloads while driving cost down.

    The Path to Autonomous Optimization

    To resolve this systemic failure, the industry has to move toward an intelligent, mathematical optimization model built for performance.

    Path to autonomous optimization: OpenTelemetry feeding an engine that tunes runtimes, pods, and nodes

    The approach starts with universal observability. After decades of proprietary agents and telemetry silos, OpenTelemetry (OTel) has finally provided a standardized baseline. Using OTel semantic conventions, organizations can collect unified, context-rich data across the whole stack, from the application runtime down to the cloud infrastructure.

    That telemetry is the fuel for an optimization engine. Instead of manual metric analysis or trial-and-error, teams need an engine that understands the relationships between runtimes, containers, scaling policies, and nodes.

    The engine turns raw observability data into actionable insights. Guided by tuning profiles, where SREs set clear optimization goals and failure-scenario simulations, this platform capability continuously determines the most efficient configuration.

    It then integrates into the developer workflow by opening a pull request directly in the GitOps repository. The recommendations carry full explainability. By showing the data-driven “why” behind every change, the platform resolves the ownership dilemma: SREs, developers, and FinOps get the confidence to review and merge insights where they already work, without derailing their primary objectives.

    System optimization must become an invisible, insight-generating platform capability. With a deterministic bridge between telemetry and action, we can finally resolve the structural conflict between performance, reliability, and cost, and let every technical team meet its goals at once.

    FAQs

    What are Day 2 operations?

    Day 2 operations are everything that happens after an application is deployed: tuning, rightsizing, scaling, and cost control in production. Day 0 is design and Day 1 is deployment. The 2026 survey finds Day 2 is where cloud-native maturity is weakest.

    Who owns Kubernetes optimization in most organizations?

    No single team, in most cases. 52% of surveyed organizations use a shared ownership model spread across developers, SREs, and FinOps. In practice, shared ownership means optimization stalls because no one is accountable for acting.

    Why is manual Kubernetes tuning not enough?

    72.6% of organizations still tune Kubernetes by hand. Manual tuning cannot keep pace with dynamic, fluctuating demand, and it consumes hundreds of engineering hours in trial and error. Deterministic, automated optimization scales where manual effort cannot.

    How do you optimize Kubernetes for both cost and performance?

    Optimize the full stack together: container limits, the application runtime, the Horizontal Pod Autoscaler, and the node layer. Only 18% of organizations tune the container and runtime together, which is where most stranded cost and reliability risk hides.

    Why does the JVM matter for cloud-native cost?

    The JVM powers 53.1% of cloud-native workloads. A JVM left on default settings inside a large container often uses only a fraction of the memory allocated to it, wasting the rest, or triggers out-of-memory kills when misconfigured. Runtime-aware tuning is essential to cloud-native efficiency.

  • Kubernetes Performance Tuning, Beyond One-Size-Fits-All: Introducing Tuning Profiles

    Kubernetes Performance Tuning, Beyond One-Size-Fits-All: Introducing Tuning Profiles

    Modern Kubernetes clusters are not monolithic; they host many applications with very different operational needs. Treating a whole cluster as one entity with a single optimization goal is a fundamental mistake. Kubernetes performance tuning only works when it respects the intent of each workload, not a cluster-wide average. That is exactly what Tuning Profiles, a new feature in Akamas Insights, now makes possible: you set a distinct optimization goal per workload — from maximum savings to maximum resilience — and the platform tunes to it.

    The classic tension between FinOps teams chasing utilization and SREs demanding safety buffers is well documented. Tuning Profiles resolves it by replacing blanket rules with context-aware, per-workload tuning.

    Why Blanket Recommendations Break Kubernetes Performance Tuning

    When SREs apply one optimization strategy across an entire cluster, the results turn chaotic. A generic engine might recommend aggressive CPU and memory cuts to remove waste. That downsizing suits a stateless background worker or a staging namespace. Applied to a mission-critical, high-traffic API, the same cuts can trigger latency spikes or Out-of-Memory (OOM) kills at peak load.

    Most tools also lack foresight about “what-if” scenarios. They base recommendations on historical averages and ignore how an application must behave during a traffic surge or a node failure. Without baking those failure scenarios into the tuning process, SREs are left guessing whether a “right-sized” pod will survive the next real stress test.

    So teams face a bad choice. They either accept recommendations blindly and risk outages, or they abandon optimization to protect stability. The usual outcome is conservative over-provisioning, because the cost of downtime outweighs the theoretical saving.

    Intent-Based Optimization: The Akamas Approach

    Akamas Insights replaces blunt resource management with surgical, context-aware optimization. Instead of forcing one metric on the whole organization, it lets Application Owners and SREs define the optimization goal for each workload.

    This matters because teams define “success” differently. An SRE team might set a “stability first” goal to eliminate OOM errors and protect reliability. A cloud-cost team might set a “cost savings” goal to reclaim waste aggressively. Tuning Profiles let each team pursue its own objective without compromising the other’s. The uniform approach gives way to a granular method that respects every deployment’s goal.

    Inside Tuning Profiles: Precision Control at Scale

    The power of Tuning Profiles lies in their flexibility. Akamas Insights no longer just tells you how to save money. It asks how a specific application needs to behave, then tunes to that answer.

    Simulating growth and traffic peaks

    Tuning Profiles move beyond historical data into forward planning. SREs can configure a profile that simulates a specific traffic increase. Anticipating a campaign or a seasonal spike, you can base recommendations on a simulated 2x or 4x rise over current traffic.

    This “Traffic Headroom” simulation guarantees that even a reduction in resources still supports the simulated peak. Optimization shifts from a reactive clean-up into proactive capacity planning. Teams find the floor of their resource needs without ever hitting the ceiling of performance.

    Granular assignment rules

    You can now tailor recommendation settings to different operational profiles. Deploy a “Max Savings” profile on development namespaces to reclaim idle resources. Apply a “High-Resilience” preset to primary services, with headroom for container restarts and traffic surges.

    Profiles can account for failure scenarios directly. A profile might reserve a 30% overhead buffer to absorb traffic spikes up to four times normal load, or hold enough headroom to survive a sudden container restart. You apply these profiles dynamically through assignment rules set at the cluster, namespace and workload levels.

    Intelligent workload exclusions

    Knowing what to leave alone matters as much as knowing what to optimize. System-critical daemonsets, security agents and infrastructure operators need static provisioning to guarantee cluster health. Akamas Insights gives you the controls to manage that.

    With Tuning Profiles, your teams can:

    • Create custom profiles from established baselines to match specific failure scenarios.
    • Compare profiles side by side to weigh performance trade-offs and safety margins before rollout.
    • Bulk-edit workloads from the UI to apply the right profile across hundreds of services at once.

    Because profiles operate on the same CPU and memory requests and limits that Kubernetes itself enforces, the recommendations stay native to how the scheduler already places and evicts pods.

    Balancing Cost and Reliability

    With targeted profiles, organizations close the gap between financial accountability and reliability. In Akamas internal benchmarks, Tuning Profiles delivered up to a 45% reduction in cloud compute cost for non-critical environments while cutting OOM errors by 60% in tier-one applications.

    The system adapts to your risk tolerance, so performance is never traded away for a smaller bill. You scale infrastructure knowing each workload is tuned to its own requirements and anticipated failure scenarios.

    FAQs

    What is a Kubernetes tuning profile?

    A tuning profile is a reusable set of optimization goals and safety constraints applied to a workload. It tells the optimizer how that workload should behave — for example, maximum savings or maximum resilience.

    How do tuning profiles improve Kubernetes performance tuning?

    They replace cluster-wide averages with per-workload intent. Each deployment is tuned to its own goal, so latency-sensitive services keep headroom while low-priority ones are reclaimed.

    Can tuning profiles prevent OOMKilled errors?

    Yes. A resilience-oriented profile reserves memory headroom and models traffic surges, which reduces the risk of OOM kills at peak load. In Akamas internal benchmarks, OOM errors fell by up to 60% in tier-one applications.

    How is intent-based optimization different from rightsizing or autoscaling?

    Rightsizing and autoscaling react to current usage. Intent-based optimization adds a goal and a simulated failure scenario, so the recommendation accounts for future peaks, not just past averages.

    How much can tuning profiles reduce Kubernetes costs?

    In Akamas internal benchmarks, non-critical environments saw up to a 45% cut in cloud compute cost, without sacrificing reliability on critical services.

  • Why Your Kubernetes Cluster Autoscaler Wastes Resources, and How to Fix It

    Why Your Kubernetes Cluster Autoscaler Wastes Resources, and How to Fix It

    Platform engineers rely on the Kubernetes cluster autoscaler to control cloud cost. However, the autoscaler is only as efficient as the node instances it provisions. When the instance type doesn’t match the workload shape, resources get stranded. The cluster autoscaler then replicates that waste at every scale-up event.

    Akamas Insights solves this with a Node Instance Optimizer. It analyzes actual workload behavior across each node pool and recommends the best instance family and size. Akamas benchmarks show 15–20% monthly cloud cost reduction from node instance optimization alone without changing application code (Source: Akamas Insights internal data, Q1 2026).

    The root of the problem is architectural. Most teams default to general-purpose instances. They treat Kubernetes autoscaling as a cost-control mechanism. But real cluster density requires matching your infrastructure shape to your workload shape. The cluster autoscaler was never designed to do that on its own.

    Why the Kubernetes Cluster Autoscaler Fails: The Bin Packing Problem

    To combat rising cloud costs, teams turn to the Kubernetes cluster autoscaler. The logic is simple: add nodes when workloads need them, remove nodes when they don’t. The problem? The autoscaler only provisions more of whatever instance type the node pool already uses.

    Consider a common scenario. Your pods are compute-intensive but light on memory. They run on general-purpose instances. The node runs out of CPU while gigabytes of memory sit unused. Kubernetes can’t schedule new pods on a node without enough CPU. That unused memory becomes stranded capacity; no workload can access it.

    How stranded resources multiply

    This creates a bin packing problem. The cluster autoscaler provisions more nodes of the same shape. Each new node carries the same wasted capacity. Cluster density drops and cloud spend climbs.

    The autoscaler didn’t fail at its job. Instead, the foundation it scales from was never optimized. The autoscaler handles scaling. Instance type selection determines whether that scaling is efficient or wasteful.

    In practice, Kubernetes resource efficiency requires alignment between workload profiles and node instance types. Without that alignment, automatic node provisioning just multiplies the mismatch.

    How Akamas Optimizes Node Instances for Each Node Pool

    Akamas Insights addresses this gap with the Node Instance Optimizer. The capability is built for platform engineers who manage multi-node-pool clusters.

    Rather than relying on utilization averages, the optimizer analyzes actual workload behavior. It then determines the best instance family and size for each individual node pool.

    Specifically, Akamas Insights examines three critical inputs that manual analysis typically misses:

    1. Pod resource profiles: the CPU and memory requests and limits of every deployed pod in the node pool.
    2. Scheduling constraints: the requirements of unusually large pods that dictate minimum node sizes.
    3. Node overheads: allocatable limits and cloud provider constraints on CPU, memory, and MaxPods.

    Based on this analysis, the optimizer recommends shifting each node pool from a general-purpose default to a purpose-matched instance type.

    For instance, migrating a node pool from m6g.2xlarge to c6g.4xlarge might seem complex. But data-driven analysis shows these workloads are compute-bound with low memory use. This shift eliminates stranded memory and improves pod scheduling efficiency. The result is the right infrastructure shape for the actual workload profile.

    Want to see what node instance optimization finds in your cluster? Start a free trial — connect your observability stack in minutes, no agents, no code changes.

    Full-Stack Savings: 15–20% Cloud Cost Reduction Without Code Changes

    By matching the instance type to the actual workload profile, organizations maintain CPU efficiency while recovering significant memory. Akamas benchmarks show a single optimized node pool typically recovers 200–400 GiB of stranded memory (Source: Akamas Insights internal data, Q1 2026). Better node utilization means fewer nodes and lower cloud spend.

    Why full-stack matters

    A Kubernetes workload runs on three layers: the application runtime (JVM, Node.js), the pod resource configuration (CPU and memory requests), and the node instance type. These layers depend on each other.

    A well-chosen instance type still wastes resources if the pod requests too much memory. A right-sized pod still gets OOMKilled if the JVM heap conflicts with the Kubernetes memory limit.

    This is why optimizing one layer at a time doesn’t work. Akamas Insights optimizes all three together: it tunes the runtime, right-sizes the pod resources, and selects the best node instance type, using actual telemetry from your cluster. When all three layers align, the cluster autoscaler finally scales density instead of waste.

    For more on common pitfalls, see our guide to Kubernetes optimization best practices.

    Explore the Akamas documentation for a full walkthrough of how pod, runtime, and node optimization work together.

    Cluster Autoscaler vs. Karpenter: Two Approaches to Node Scaling

    The Kubernetes cluster autoscaler and AWS Karpenter both handle node-level scaling. However, they solve different problems.

    The cluster autoscaler works with predefined node groups. It adds or removes nodes from existing pools based on pending pods. Karpenter takes a different approach. It provisions individual nodes with the right instance type for each pending pod. It bypasses node groups entirely.

    Where Akamas fits

    Karpenter is strong at choosing the right node when a pod needs to be scheduled. However, it only sees what the pod requests at that moment. It doesn’t know whether those resource requests are well-tuned, or whether the application runtime inside the container is configured efficiently.

    Akamas Insights works from the opposite direction. It observes how workloads actually behave over days and weeks: how much CPU and memory they consume in practice, how runtime settings affect resource use, and where the gap sits between what pods request and what they need. Based on that observed data, it recommends the right instance type for each node pool.

    For organizations using the cluster autoscaler, Akamas addresses the root cause of waste: wrong instance types that strand resources at every scale-up. For organizations using Karpenter, Akamas complements the provisioner. It optimizes the pod resource settings and runtime configurations that Karpenter uses as inputs for its decisions.

    The key difference: Karpenter optimizes provisioning decisions at scheduling time. Akamas optimizes the workload configurations and infrastructure foundations that determine whether those decisions are efficient.rmine whether those provisioning decisions are efficient.

    See how Akamas complements your current scaling setup. Book a demo with our team, or start a free trial to test it against your own cluster data.

    FAQs

    What is the Kubernetes cluster autoscaler and what does it do?

    The Kubernetes cluster autoscaler adds or removes nodes based on pending pod scheduling needs. It watches for pods that can’t be scheduled due to resource limits. Then it provisions new nodes to make room. However, the autoscaler does not evaluate whether the node instance type fits the workloads running on the cluster.

    Why does the Kubernetes cluster autoscaler waste resources?

    The autoscaler provisions the same instance type configured for the node pool. It ignores actual workload profiles. When pods need lots of CPU but little memory, general-purpose instances leave memory stranded. The autoscaler then adds more nodes of the same shape. Each new node replicates the same waste.

    How does node instance optimization reduce Kubernetes cluster cost?

    Node instance optimization matches the instance type to the workload’s actual resource profile. It analyzes CPU-to-memory ratios, scheduling constraints, and pod sizes. Then it recommends the right instance family. Akamas benchmarks show 15–20% monthly cost reduction by eliminating stranded resources (Source: Akamas Insights internal data, Q1 2026).

    What is the difference between Karpenter and the cluster autoscaler?

    The cluster autoscaler scales predefined node groups up and down. Karpenter provisions individual nodes with instance types chosen per pod at scheduling time. Both handle node scaling. Neither optimizes the workload configurations — pod resources, runtime settings — that determine whether scaling is efficient. Akamas Insights optimizes those workload-level settings using observed data.

    Can I optimize the cluster autoscaler without changing my applications?

    Yes. Node instance optimization works at the infrastructure layer. It changes the instance type for each node pool. Your applications keep running unchanged, but on infrastructure that better matches their resource needs.

    How does node instance optimization relate to pod rightsizing?

    Pod rightsizing adjusts CPU and memory requests at the container level. Node instance optimization selects the right infrastructure shape at the node pool level. Akamas Insights optimizes both together, along with runtime settings. This delivers compound savings across the full Kubernetes stack.

  • Beyond the JVM: Full-Stack Optimization for Node.js on Kubernetes

    Beyond the JVM: Full-Stack Optimization for Node.js on Kubernetes

    The promise of Kubernetes lies in seamless scalability, yet running high-performance Node.js applications often reveals “invisible” friction. While JVM tuning has a long history of optimization, many Node.js deployments still rely on V8 defaults originally designed for the browser, not the high-density environment of containerized microservices.

    Akamas Insights now optimizes the Node.js (V8) runtime on Kubernetes. It tunes V8 memory flags and pod CPU limits together, so applications stop hitting CPU throttling and out-of-memory kills. In production benchmarks, this cut CPU overhead by 68% with no code changes.

    Even for the JVM, which is often considered “solved”, achieving peak efficiency remains a moving target. As we previously explored in our JVM performance studies, there is still significant room for optimization in modern cloud-native environments. At Akamas, we believe efficiency should be automated, not a manual burden. By bridging the gap between Kubernetes orchestration and V8’s internal mechanics, Akamas Insights lets SREs and Platform Engineers move beyond basic “right-sizing” and achieve true full-stack harmony.

    The Hidden Bottleneck: The V8 Configuration Gap

    Node.js is built on V8, Google’s high-performance JavaScript engine. While V8’s generational garbage collector is a marvel of engineering, its default heuristics often clash with the rigid boundaries of a Kubernetes pod.

    In many cases, the runtime is unaware of the tight memory constraints of a container, leading to a “reliability trap”. If the V8 heap is sized too aggressively, the container hits a hard limit and suffers an Out-Of-Memory (OOM) kill. If it is sized too conservatively, the engine triggers excessive Garbage Collection (GC) cycles. Those cycles steal CPU from the application, and once the container exceeds its CPU limit, Kubernetes throttles it. The result is added latency at exactly the wrong moment.

    The impact of these suboptimal defaults is most visible during Horizontal Pod Autoscaling (HPA) events. In high-demand scenarios Node.js applications often struggle with “warm-up” friction. As the HPA triggers new pods to handle a spike, the V8 engine’s initial optimization and memory allocation phases can cause a lag in responsiveness, exactly when the system needs to be at its fastest.

    The potential for improvement is significant. By moving beyond generic defaults and tuning V8 specifically for the container’s resource profile, we have demonstrated response time reductions of up to 35% for major enterprise applications (Akamas Insights production benchmarks, 2026). This isn’t just about “tuning”; it’s about reclaiming wasted resources and ensuring the runtime and the orchestrator work in tandem.

    The Akamas Way: Vertical Full-Stack Optimization

    Traditional optimization tools look at the world through a single lens, either the infrastructure or the application. Akamas Insights takes a vertical approach. A Node.js application is a layered stack, and every level affects the next.

    True efficiency requires coordinating three critical layers:

    • The V8 runtime: tuning parameters like --max-semi-space-size and --max-old-space-size to minimize GC pressure and maximize execution speed.
    • The Kubernetes pod: aligning CPU and memory requests and limits to the actual footprint of the optimized runtime, preventing throttles and OOM events.
    • The Horizontal Pod Autoscaler (HPA): synchronizing scaling logic with the new resource boundaries to prevent “flapping” and instability.

    By treating these layers as a single living organism, Akamas Insights identifies optimization opportunities that are impossible to find when looking at containers in isolation. The same full-stack approach already tunes JVM workloads on Kubernetes; it now extends to application runtimes like Node.js.

    From Analysis to Impact: 2x Performance Gains

    The impact of this data-driven approach is significant. In recent production benchmarks, we applied Akamas Insights to enterprise-grade Node.js workloads. By moving away from V8 defaults and identifying the optimal configuration for heap generation sizing, we achieved a 45% increase in application throughput and a 68% reduction in CPU overhead (Akamas Insights production benchmarks, 2026).

    These gains do not require a single line of code change. They are the result of data-driven tuning that calibrates the engine for its environment. When the runtime is healthy, the application uses fewer resources to do more work. That translates directly to lower cloud costs and higher service reliability.

    Engineering the Michelin Standard

    The addition of Node.js support to Akamas Insights marks a shift toward a more sophisticated era of optimization. We are moving away from the “one-size-fits-all” approach to infrastructure and toward a culture of precision and real full-stack optimization.

    With Akamas, your SRE and FinOps teams no longer have to choose between performance and cost. By providing visibility into the “black box” of the V8 engine and automating the discovery of optimal configurations, we empower your developers to deliver a flawless user experience alongside a well-managed budget. Eliminate the performance overhead of default V8 settings and ensure predictable autoscaling. Start your free trial of Akamas to achieve full-stack harmony between Node.js and Kubernetes.

    FAQs

    What is CPU throttling in Kubernetes?

    CPU throttling happens when a container exceeds its CPU limit. Kubernetes then restricts the container’s CPU time, which adds latency. For Node.js, excessive V8 garbage collection is a common trigger, because GC cycles consume CPU the application needs.

    How do you stop Node.js CPU throttling on Kubernetes?

    Tune the V8 heap so garbage collection runs less often, then align pod CPU requests and limits to the optimized runtime. Akamas Insights tunes both layers together. In production benchmarks, this cut CPU overhead by 68% with no code changes.

    Which V8 flags matter for Node.js in containers?

    The two most important flags are --max-old-space-size and --max-semi-space-size. They control heap sizing and how often V8 runs garbage collection. Setting them for the container’s memory profile prevents both OOM kills and excessive GC.

    How do you prevent Node.js from getting OOMKilled on Kubernetes?

    Size the V8 heap below the pod memory limit, not above it. If --max-old-space-size exceeds the container limit, the pod hits a hard boundary and Kubernetes kills it. Akamas aligns heap size with pod limits automatically.

    Does tuning V8 for Kubernetes require code changes?

    No. The gains come from configuration, not code. Akamas Insights identifies the optimal V8 flags and pod resource settings from observed workload behavior, so developers ship no changes.

  • Scaling from the Right Foundation: Introducing HPA-Aware Optimization in Akamas Insights

    Scaling from the Right Foundation: Introducing HPA-Aware Optimization in Akamas Insights

    Modern Kubernetes environments rely heavily on the Horizontal Pod Autoscaler (HPA) and tools like KEDA to manage dynamic workloads. Autoscaling is a powerful mechanism for handling peak traffic, but autoscaling alone does not guarantee efficiency. One of the most overlooked Kubernetes HPA best practices is simple: fix the foundation before you scale it. Scaling from a poorly configured resource baseline simply amplifies the inefficiencies already in your cluster.

    Today we are pleased to announce native support to optimize HPA workloads in Akamas Insights, bringing full-stack, autonomous optimization to your most dynamic and business-critical services.

    The Hidden Tax of Over-Provisioning and Manual Toil

    Platform Engineers and SREs are intimately familiar with the just to be safe tax. To prevent CPU throttling or agonizingly slow scale-ups during sudden traffic spikes, engineering teams routinely over-provision pod replicas, CPU requests, and memory limits. This brute-force approach might temporarily protect uptime, but it actively destroys cluster density and drives up cloud cost.

    It also leads to the Scaling Paradox, where the very mechanism intended to provide stability introduces new failure modes. Teams struggle to find the right balance between vertical and horizontal scaling: many small pods, or fewer large ones? The problem is compounded because HPA and the Vertical Pod Autoscaler (VPA) do not work well together on the same signal. The VPA also has no awareness of application runtimes, so it can set misaligned resource requests that trigger instability rather than resolving it.

    Trying to solve this by manually tuning complex runtimes alongside HPA introduces massive operational toil. Application runtimes like the JVM or Node.js were not designed for volatile, resource-constrained container environments. When CPU and memory requests are misaligned with real workload behavior, frequent scaling leads to instability. Teams see pod flapping, cold-start penalties during JIT compilation, and degraded reliability exactly when the application needs to perform.

    The Akamas Way: Orchestrating a High-Performance Foundation

    Akamas Insights now brings native optimization directly to workloads governed by HPA. Rather than modifying your carefully crafted scaling thresholds or HPA policies, the platform optimizes the foundational configuration from which scaling occurs.

    By right-sizing CPU and memory requests, limits, and runtime configurations, Akamas ensures your HPA scales from an efficient and stable starting point. This supports a safe, predictable rollout: the Horizontal Pod Autoscaler keeps operating exactly as intended, but with far better resource utilization.

    Deep Dive: How HPA-Aware Optimization Works

    Our latest release goes beyond simple resource tracking. It synchronizes your vertical configuration with your horizontal scaling strategy, which is where most Kubernetes HPA best practices break down in real clusters.

    Uncovering Hidden Inefficiencies in Scaling Behavior

    Many HPA-related performance issues are invisible to standard monitoring. Akamas proactively identifies friction points that are notoriously hard to detect by hand:

    • CPU throttling during application initialization (such as JVM JIT compilation) makes new replicas lag, forcing the HPA to spin up even more unnecessary pods.
    • Scaling thresholds set too high to trigger before performance degrades, or max-replica limits set too low to absorb peak traffic safely.
    • Container resource limits that conflict with the application runtime’s own memory management or garbage collection settings.

    Precision Recommendations for Stable Scaling

    Once these risks are identified, Akamas provides a unified recommendation to stabilize your workloads. Instead of guessing at pod sizes or HPA configurations, Akamas determines the precise mix of CPU/memory requests, runtime parameters, and scaling thresholds required to meet your specific goals.

    This full-stack optimization approach delivers two things at once:

    • Maximized efficiency. Akamas tunes min/max replicas and scaling thresholds so you are not running idle capacity. Cluster density rises and cloud spend falls.
    • Guaranteed performance. By optimizing the “unit of scale” (the pod) alongside the scaling policy, Akamas makes every new replica stable and ready to serve load immediately. This removes the performance dips that occur when unoptimized runtimes hit sudden stress.

    The Impact of a Right-Sized Foundation

    By treating the whole stack as a single, interconnected system, teams can transform their Kubernetes efficiency. Akamas handles pod sizing, JVM/Node.js tuning, and HPA configuration as one unified challenge rather than three isolated tasks.

    Early Akamas Insights optimization data shows that fixing the HPA baseline lets platform teams cut compute waste by up to 35% while raising cluster density. Just as important, it removes the manual toil of tuning runtimes and HPA thresholds separately. The result is 99.9% stable scaling and far fewer of the start-up incidents that occur when unoptimized runtimes buckle under rapid scaling.

    Instead of spending hours manually tuning JVM parameters, sizing pods, and adjusting HPA thresholds in isolation, your team optimizes across the entire stack. This automated framework ensures your infrastructure is not just scaling, but scaling on a foundation built for performance and reliability.

    Ready to eliminate the “just to be safe” tax and stabilize your autoscaling? Start your free trial of Akamas today and see how HPA-aware optimization can transform your cluster efficiency.

    FAQs

    What is HPA in Kubernetes?

    The Horizontal Pod Autoscaler (HPA) adds or removes pod replicas based on observed metrics like CPU or memory. It scales a workload horizontally to match demand.

    How does HPA work in Kubernetes?

    HPA compares a target value (for example, 70% CPU) against current usage. It then calculates how many replicas are needed and adjusts the deployment automatically.

    What is the difference between HPA and VPA?

    HPA changes the number of pods. VPA changes the CPU and memory requests of each pod. Running both on the same metric usually causes them to fight each other.

    Does HPA need correct resource requests?

    Yes. HPA reads utilization as a percentage of each pod’s requests. Wrong requests make HPA scale too early, too late, or erratically.

    How do you optimize HPA for cost and stability?

    Right-size pod requests, limits, and runtime settings first. Then set min/max replicas and thresholds so scaling always starts from an efficient, stable baseline.

  • Beyond the “Black Box”: Empowering Developers with GitOps-Driven Optimization

    Beyond the “Black Box”: Empowering Developers with GitOps-Driven Optimization

    In the modern, cloud-native enterprise, the mantra of “you build it, you run it” has transformed the Application Developer. Once a pure coder, the developer is now a guardian of service health, cost, and performance. As Kubernetes environments grow in complexity, the pressure to maintain this ownership keeps rising. It has driven a proliferation of “automated” solutions promising to take the burden of resource management off the developer’s plate. Yet, for many, these autonomous agents have become a new source of anxiety.

    The promise of hands-off optimization often masks a loss of visibility and control. When a black-box agent modifies a deployment in real-time, it bypasses the standard delivery pipelines. That creates a disconnect between the code in the repository and the state of the cluster. This “shadow configuration” leaves developers feeling like passengers in their own applications. They fear that an invisible change might trigger a production incident they cannot easily trace or roll back.

    The real fix is not better automation. It is GitOps Kubernetes optimization: every tuning change arrives as a reviewable pull request, never a silent edit.

    The Burden of the Manual Middle Ground

    The alternative to high-risk autonomy is often a grueling manual process that drains engineering velocity. Developers find themselves trapped in a cycle of “YAML fatigue.” Optimizing a microservice requires a context switch away from feature development. They must manually interpret telemetry, calculate new CPU and memory limits, and submit repetitive pull requests. This manual approach is not only slow but inherently reactive. A developer rarely has the bandwidth to address an over-provisioning issue or a latent performance bottleneck in time. By the time they do, the application requirements may have already shifted. This gap between insight and action creates a “frozen” infrastructure. Configurations sit at safe, bloated levels. The cost of manual tuning is too high; the risk of automated “black-box” changes is too great.

    The Akamas Way: Optimization as Code

    Akamas Insights introduces a third path that harmonizes the intelligence of AI-driven optimization with the rigor of GitOps workflows. It does not act as a separate, invisible layer that manipulates the cluster behind the developer’s back. Instead, Akamas Insights integrates directly into the existing “Source of Truth”: the Git repository.

    This is the DevEx approach to performance: meeting developers exactly where they already live. Application owners no longer log into yet another dashboard or learn a new optimization syntax. Akamas surfaces actionable intelligence directly within the tools they use every day. By treating optimization recommendations as part of the standard CI/CD lifecycle, Akamas provides the necessary insights with minimal distraction. Rather than applying these changes autonomously and creating “shadow configurations,” Akamas feeds them into the GitOps pipeline as a standard Pull Request. Every optimization stays visible, versioned, and verified, with minimal effort from the engineering team.

    GitOps workflow showing Akamas AI generating optimization pull requests with human review and cluster deployment

    Technical Mechanics: How GitOps on Kubernetes Closes the Optimization Loop

    The integration between Akamas Insights and GitOps keeps the developer’s workflow intact while removing the analytical heavy lifting. This process follows a structured, transparent path:

    • Telemetry Aggregation and Analysis: Akamas continuously monitors application performance and resource utilization. It identifies the “perfect fit” for the current workload, based on defined Tuning Profiles.
    • Evidence-Based Recommendation Engine: Before proposing a change, Akamas identifies specific optimization opportunities. Examples: right-sizing CPU limits to eliminate throttling, or adjusting JVM heap sizes to cut garbage collection overhead. This approach ensures that every recommendation is grounded in high-fidelity historical data and our unique machine learning models. Akamas decodes the intricate relationship between application runtime dynamics and Kubernetes scaling behavior. It moves beyond generic heuristics to deliver optimization scientifically tailored to your specific workload.
    • Automated Pull Request with Built-in Explainability: Akamas triggers a workflow to create a Pull Request (PR) against the application’s configuration repository. This PR acts as the focal point for trust. It includes a detailed “Evidence Report” that explains the “Why” behind the change. Developers can see the identified bottlenecks, the simulated impact on performance, and the projected cost savings. By showing the data behind the conclusion, Akamas turns the “black box” into an open book. Developers can understand it and trust it.
    • Human-in-the-Loop Validation: The application owner reviews the PR just like any other code contribution. Akamas simulates and documents the impact inside the PR. The developer approves with confidence, knowing exactly how the new values.yaml or deployment manifests will behave in production.
    • GitOps Reconciliation: Upon approval and merge, the existing GitOps controller detects the change. Tools such as Argo CD or Flux then synchronize the cluster to the new, optimized state.

    This approach ensures 100% configuration traceability. If an issue arises, the developer reverts to a previous state with standard Git commands. The same safety nets used for application code apply here too.

    Akamas Insights recommendation showing CPU and memory optimization with GitOps pull request creation

    TThe Impact: Speed Without Sacrifice

    Shift from manual tuning to an intelligent, full-stack optimization model integrated with the GitOps workflow. Organizations then reach continuous optimization without sacrificing developer sovereignty. This creates a quantifiable shift in how teams manage their digital footprint:

    • Elimination of Configuration Drift: Since all changes pass through Git, the “Source of Truth” always matches the production environment. No more mystery about why a pod’s limits changed.
    • Developer Velocity: Teams have reported reducing time spent on resource configuration by up to 80%, because Akamas handles the “Analyze” phase entirely.
    • Predictable Efficiency and Performance: Organizations can realize significant cost reductions, often exceeding 25% of cloud spend. They avoid the “flapping” and instability of real-time autonomous agents.

    Conclusion

    True innovation in the cloud-native space is not about replacing the developer with an algorithm; it is about empowering the developer with better tools. Akamas Insights, coupled with GitOps integration, transforms optimization from a chore into a strategic advantage. It provides the precision of AI with the safety of a versioned workflow. Application owners reclaim control of their services, while keeping them at peak performance and efficiency. To see how Akamas Insights brings harmony to your GitOps workflow and ends the burden of manual tuning, explore our documentation or try Akamas Insights today.

    FAQs

    What is GitOps Kubernetes optimization?

    It is the practice of delivering Kubernetes tuning changes through Git rather than applying them straight to the cluster. Each recommendation arrives as a versioned pull request, gets reviewed, and is merged like any code change. A GitOps controller then reconciles the cluster to the new state.

    How is this different from black-box or autonomous optimization?

    Black-box agents modify the cluster in real time, with no review and no recorded reason. That creates “shadow configuration” and drift. GitOps optimization routes the same change through a pull request, so the developer sees the diff and the evidence before anything merges.

    Does it work with Argo CD and Flux?

    Yes. Akamas opens a standard pull request against your configuration repository. Your existing GitOps controller, such as Argo CD or Flux, reconciles the merged change on its next sync.

    Do developers still control the changes?

    Yes. The recommendation is generated automatically, but a person approves the merge. Each PR includes an Evidence Report with the bottleneck, the simulated impact, and the projected cost savings, so the reviewer can decide with confidence.

    Can I roll back an optimization?

    Yes. Because every change passes through Git, you revert with standard Git commands. The “Source of Truth” always matches production, which gives you full configuration traceability.

  • The State of Java on Kubernetes 2026: Why Defaults are Killing Your Performance

    The State of Java on Kubernetes 2026: Why Defaults are Killing Your Performance

    Java is the backbone of enterprise software, and Kubernetes is the standard for deployment. You would assume that by 2026 these two technologies would work perfectly together out of the box. They do not. Most Java workloads on Kubernetes run with default JVM settings that quietly waste memory, throttle CPU, and slow requests.

    The data confirms Java’s dominance. According to the Azul State of Java Survey 2025, 68% of enterprises report that the majority of their applications run on the JVM. New Relic’s 2024 State of the Java Ecosystem found that adoption of container-friendly Java versions like Java 17 and 21 has surged by nearly 300%, proving that Java is being aggressively modernized for the cloud.

    Unfortunately, while adoption is high, performance and efficiency are low.

    In our recent webinar, Stefano Doni (CTO at Akamas) and Bruno Borges (Principal Program Manager at Microsoft and Java Champion) analyzed the state of the industry. After reviewing data from thousands of JVMs running in production environments globally, the verdict was clear: the majority of Java workloads on Kubernetes are running with “default” settings that are actively hurting performance and wasting money.

    Here is a look at what the data says, why “safe” defaults are dangerous in the cloud, and how you can fix it.

    How Are We Configuring JVMs?

    The premise of modern DevOps is automation and efficiency. However, the reality is that most organizations are “lifting and shifting” their Java applications into containers without adjusting the Java Virtual Machine (JVM) configuration.

    This isn’t a new problem, but it is getting worse. During the session, Bruno Borges referenced historical data from New Relic, highlighting that for years, over 65% of workloads lacked explicit Garbage Collection (GC) tuning.

    But that was about 5 years ago. How is the situation now? Stefano Doni then presented Akamas’s 2025 research, analyzing thousands of Java workloads being optimized in our platform. The data confirms that despite the maturity of Kubernetes and Java, these bad habits persist today.

    Chart: 60% of Java workloads on Kubernetes run with an unset garbage collector (Akamas 2025 data)

    According to our data:

    • 60% of JVMs have an unset Garbage Collector. The JVM then picks a default algorithm that may not match your container size or latency requirements.
    • The majority of Heap configurations are unset. Most developers rely on the JVM’s automatic memory management.
    • Most containers are too small. Many JVMs run with less than 1 CPU or less than 1 GiB of RAM. That is a major bottleneck for Java’s multi-threaded architecture.
    Chart: CPU core allocation distribution for Java pods on Kubernetes, many under one core
    Chart: JVM maximum heap size distribution on Kubernetes, most heaps left at conservative defaults

    Why is this happening? As Bruno Borges highlighted, many developers assume “the JVM will tune itself”. The JVM ergonomics are smart, but they were originally designed for large, shared physical servers, not for the constrained resources of isolated Kubernetes pods.

    Ergonomics is the process by which the Java Virtual Machine (JVM) and garbage collection tuning, such as behavior-based tuning, improve application performance. The JVM provides platform-dependent default selections for the garbage collector, heap size, and runtime compiler. These selections match the needs of different types of applications while requiring less command-line tuning. In addition, behavior-based tuning dynamically tunes the sizes of the heap to meet a specified behavior of the application.

    Oracle Java Documentation

    The reality is that default JVM heuristics are far from optimal. Their impact on your workloads is invisible but significant.

    Wasting Cloud Resources

    The most common mistake is leaving the Heap Size unset (no -Xmx or -XX:MaxRAMPercentage).

    Modern JVMs (Java 10+) are “container-aware”, meaning they attempt to self-configure based on the resources assigned to the container. However, this default behavior is incredibly conservative. For typical production containers (those allocated above 512MB of memory), the JVM uses only 25% of the container memory limit for the heap.

    Note: For very small containers (<256MB), the JVM acts differently, taking up to 50%, but most enterprise workloads fall into the larger category where the 25% rule applies.

    This default creates a paradox around resource efficiency. Imagine you configure a pod with 2GB of memory requests and limits. You are reserving 2GB of cluster capacity for that container. Because you relied on defaults, the JVM sees that limit but allocates only 512MB to your application’s heap. The remaining 1.5GB is technically available for non-heap memory, yet a typical microservice rarely needs 1.5GB of overhead. You are effectively leaving almost 75% of your memory on the table, paying for capacity your application is forbidden from touching.

    Beyond the waste, this configuration undermines performance and stability. Because the heap is restricted to a small fraction of available memory, your application fills it up much faster than necessary. That triggers frequent, aggressive Garbage Collection cycles to reclaim space, leading to CPU spikes and latency, even though the container has plenty of free memory.

    What happens when you leave your GC Unset?

    The Garbage Collector (GC) is the single most impactful factor on application latency and throughput. The research data shows that nearly 60% of Java workloads leave the Garbage Collector type unset. This forces the JVM to rely on its ergonomics to choose an algorithm for you.

    By default, modern Java versions prefer the G1GC collector, designed for high throughput and low latency. However, the JVM only enables G1GC if it detects at least 2 CPUs and 1791MB of RAM.

    Diagram: JVM ergonomics selects G1GC or SerialGC on Kubernetes based on CPU and memory thresholds

    If you deploy a microservice with a standard “cost-saving” configuration of 1 CPU or less, the JVM silently downgrades the Garbage Collector to SerialGC. Unlike G1GC, which runs concurrently, SerialGC performs memory cleanup using a single thread, freezing your application entirely for the duration of the collection.

    There is a second trap just above that threshold. When a container is just large enough to select G1GC (say, exactly two CPUs), you hit a technical paradox. G1GC spins up worker threads to clean memory in parallel. In such a constrained environment those threads crowd the very few cores available. Instead of streamlining the work, the CPU wastes cycles on constant context switching between your application logic and the swarm of background GC threads.

    This convenience of “automatic” selection is a double-edged sword. It often chooses a GC that is not optimal for your performance or footprint goals, and it does so silently. Because the JVM shifts its entire memory management strategy based on an apparently unrelated setting like the CPU limit, it can introduce performance penalties that are hard to diagnose. Relying on these defaults means ignoring the delicate balance between threads and cores. You are left at risk of a single-threaded bottleneck on one side and multi-threaded overhead on a small node on the other.

    The High Cost of “Micro-Containers”

    One of the most pervasive trends is the deployment of JVMs with less than 1 CPU. This looks efficient on a spreadsheet, and it is often chosen to reduce the “blast radius” by spreading instances. For Java it creates a fundamental architectural conflict, forcing a trade-off between cost and application stability.

    A Kubernetes CPU limit is not a “speed limit” that slows down the processor. It is a “time quota” enforced by the Linux kernel’s Completely Fair Scheduler (CFS). Typically the kernel divides time into 100ms windows. If you assign a container a limit of 500m (0.5 CPU), you are granting it 50ms of runtime every 100ms. Your JVM can still see all the CPUs of your Kubernetes node. Once that quota is exhausted, the kernel throttles the container: it freezes all threads until the next window begins.

    This mechanism is disastrous for Java because of its multi-threaded nature. The JVM is not just running your code. It constantly runs background threads for the Just-In-Time (JIT) compiler and the Garbage Collector.

    When your application starts or hits a new “hot” code path, the JIT compiler kicks in to transform bytecode into optimized machine code. This process is CPU-intensive. In a micro-container, a JIT burst can consume the entire 50ms quota in an instant. The Linux kernel then forcibly pauses your application for the remaining 50ms of the window. To your users this looks like latency, but it is actually an OS-enforced sleep where no code is executing.

    The sheer density of threads inside the JVM makes this worse. Even a simple application spawns dozens of threads: Garbage Collection threads, compiler threads, and your application threads. When you constrain a Java pod to less than 1 CPU, all these threads fight for those microscopic time slices. The background maintenance tasks, which are supposed to be invisible helpers, become active obstructors of your business logic.

    This contention damages performance regardless of which Garbage Collector you use. Modern concurrent collectors (like G1GC, ZGC, and Shenandoah) clean memory in the background using worker threads named ParallelGCThreads and ConcGCThreads. Tight CPU limits force the Kubernetes scheduler to throttle these threads, slowing user requests so the GC can proceed. When the inevitable “Stop-The-World” pause occurs, a phase required by all collectors, the lack of available CPU cycles means the cleanup takes significantly longer.

    This explains the findings from the benchmarks discussed by Bruno Borges. When comparing six small replicas (1 CPU each) against two larger replicas (3 CPUs each), the results revealed a clear performance gap. With the exact same total CPU capacity, the two larger replicas delivered significantly better throughput and lower tail latency. Giving the JVM “breathing room” reduces the probability of hitting these throttling walls. It also ensures background threads run on separate cores without freezing the request-processing threads.

    Benchmark chart: two larger Java replicas beat six small replicas on throughput and tail latency at equal CPU

    The Ecosystem Is Reacting

    The industry is aware of these challenges, and during the webinar Bruno Borges shared several initiatives aimed at mitigating them.

    Tools like the Azure Command Launcher for Java (“jaz”) automate the configuration of JVM flags based on the environment, effectively tuning the startup command for you. Projects within the OpenJDK ecosystem, such as Project Leyden and CRaC (Coordinated Restore at Checkpoint), are making strides to reduce startup times and memory footprint through static images and snapshotting.

    These advancements help developers start on the right foot. They do not eliminate the fundamental need to manage the performance and efficiency trade-offs of running Java in Kubernetes. Even with a perfectly tuned startup command or a faster boot time, once your application is running under load the tension between memory, CPU, and latency remains.

    Stop Guessing, Start Measuring

    The days of manual tuning are over. Even well-intentioned attempts to “fix” these issues by hand often backfire.

    Real efficiency requires balancing Throughput, Latency, and Footprint. Improving one often comes at the expense of the others.

    • Maximize Throughput? You may need a larger heap, increasing your Footprint.
    • Minimize Footprint? You risk squeezing the JVM and destroying your Latency.

    To solve this puzzle you cannot look at the JVM in isolation. You must align JVM configuration with Kubernetes container resources and HPA scaling policies at the same time. It is a trade-off between wasting money on over-provisioning and risking reliability with under-provisioning. It has to be done for every Java workload, continuously, as traffic changes and new releases reach production.

    You don’t need to solve this multi-variable equation manually. You can use Akamas Insights to run a comprehensive health check of your Java applications on your Kubernetes clusters. By connecting to your existing observability tool (like Prometheus, Datadog, and Dynatrace), Akamas Insights analyzes the full picture: JVM metrics, container limits, and actual usage. It tells you exactly where you are sacrificing reliability for cost, or the reverse.

    Stop flying blind: Get your free Application Health Score with Akamas Insights now.

    FAQs

    Which garbage collector does the JVM use by default on Kubernetes?

    It depends on the resources the JVM detects. With at least 2 CPUs and 1791MB of RAM, the JVM selects G1GC. Below that threshold it silently falls back to the single-threaded SerialGC.

    How much heap does the JVM allocate by default in a container?

    For containers above 512MB, a container-aware JVM (Java 10+) uses only 25% of the memory limit for the heap by default. Set -XX:MaxRAMPercentage or -Xmx to reclaim the rest.

    Why do Java pods with less than 1 CPU perform poorly?

    A Kubernetes CPU limit is a time quota enforced by the Linux CFS scheduler, not a speed limit. A 500m limit grants 50ms of runtime per 100ms window. JIT and GC threads exhaust that quota quickly, so the kernel throttles the pod and requests stall.

    What is CPU throttling in Kubernetes?

    Throttling is the kernel pausing a container once it spends its CFS time quota for the current window. The container waits, idle, until the next window. For Java this freezes application, JIT, and GC threads together.

    Are fewer large replicas better than many small ones for Java?

    Often yes. At equal total CPU, benchmarks showed two 3-CPU replicas beat six 1-CPU replicas on throughput and tail latency, because larger CPU limits reduce throttling and give background threads room to run.

  • Kubernetes Performance Testing for Cloud-Native Apps: How Akamas and Speedscale Close the Loop

    Kubernetes Performance Testing for Cloud-Native Apps: How Akamas and Speedscale Close the Loop

    Kubernetes went from novelty to default in about a decade. As of 2024, over 60% of enterprises had adopted it as their de facto container orchestration solution, and that number is projected to exceed 90% by the end of 2027.

    Kubernetes performance testing validates how containerized workloads behave under realistic load before release. Cloud-native stacks need two things that traditional tooling keeps apart: realistic traffic, and automated configuration tuning. Speedscale replays sanitized production traffic. Akamas learns the optimal configuration from each test run. Together they form a closed loop.

    This article covers why traditional performance engineering breaks on Kubernetes, what each platform contributes, and how the two combine inside a CI/CD pipeline.

    Why Kubernetes performance testing breaks traditional methods

    Modern application architecture runs on microservices and container orchestration. The methodologies teams used to tune monoliths struggle badly when pointed at containerized applications. Going from monolith to microservices simply adds moving parts.

    A single microservice usually depends on other services. Those dependency chains are difficult to map and harder to test completely. A bottleneck in one service cascades and surfaces as an issue in a service that looks unrelated. The real root cause gets buried.

    Four problems account for most of the pain:

    ProblemWhat it does to your test results
    Kubernetes configuration surfacePod requests, limits, autoscaling policies and runtime flags interact, so a fix in one layer creates a regression in another
    Cloud elasticityInfrastructure changes underneath a test run, so response time and throughput are never repeatable
    Test environment fidelityMocks drift from reality, and copying production data creates privacy exposure
    Synthetic workloadsA best-guess traffic model does not reproduce what production actually does

    Kubernetes-specific performance pitfalls

    Kubernetes carries its own set of performance pitfalls, and they hit reliability, user experience and cost at the same time. We covered the full list in our top 10 Kubernetes performance pitfalls. The most common ones:

    • Pod CPU requests and limits set from a guess rather than from observed behaviour
    • Node resources, especially memory, exhausted before the autoscaler reacts
    • Cluster autoscaling that provisions the wrong capacity at the wrong time
    • Application runtime settings left at their defaults

    That last one deserves its own paragraph. Java applications on Kubernetes are particularly awkward, because the JVM exposes a very large configuration surface and its defaults were never designed for containers. Akamas research found that Java on Kubernetes accounts for over 50% of cloud costs according to 62% of the organisations surveyed (The State of Java on Kubernetes 2026). Node.js applications hit similar trouble for a different reason: their runtime characteristics are unusual and, in many cases, poorly documented. We go deeper on both in application runtime optimization.

    Balancing performance, reliability and cost across all of that by hand is not realistic.

    The cloud is not magic: elasticity destroys your baseline

    Plenty of people still believe the cloud has unlimited resources. It can certainly auto-scale on demand, and for performance testing that cuts both ways. A poorly written application will consume every resource you hand it, and the bill arrives later.

    Elasticity is excellent for uptime. It is terrible for baselines. Consistent, reliable test results become hard to get, because the infrastructure under a test run can change mid-test.

    Multi-tenant interference makes it worse. Noisy neighbours skew accuracy, mask real issues, and produce false positives during peak testing windows. Shared, dynamically allocated resources are the opposite of the controlled, repeatable conditions that performance testing has always needed. That gap is why predicting real-world performance, or justifying an optimization to a finance team, gets so difficult.

    Test environment bottlenecks in microservices testing

    Environments have always been the tar pit of performance testing projects. Microservices made it worse. Building realistic, isolated, cost-effective test environments that genuinely replicate production is often the single largest bottleneck in the process, and it drags on the whole agile cycle.

    Consider one service with several dependencies. Testing it in isolation means mocking those dependencies. Integration testing means running the entire chain. Traditional mocks rarely reflect the diversity of real data and have to be maintained forever. Results get distorted, and the maintenance effort is time-consuming and error-prone.

    Using production data instead is a terrible idea unless it has been obfuscated. PII, financial records and health information carry serious privacy and compliance exposure. Full production datasets are often too large to copy. Periodic database dumps go stale and miss schema changes.

    The outcome is predictable. Teams cannot stand up production-like environments quickly, so they compromise, and the compromises produce unreliable results and a higher risk of production failures.

    Where traditional load testing tools fall short

    Traditional load testing tools have to change to meet what cloud-native applications demand. Two limitations dominate.

    LimitationConsequence
    Scripted test casesTools like JMeter need scripting and plugins before they return anything useful, and many teams cannot fund the maintenance
    Synthetic workload modelsA workload built from anecdotal input from the test team or ops does not capture what production actually receives

    Run those tests and you still learn very little about how the application will behave in the real world.

    Akamas: AI-driven tuning for Kubernetes performance testing

    Akamas moves configuration decisions off trial and error and onto data. It searches the configuration space and returns the settings that deliver the best performance and efficiency, in a fraction of the time manual tuning takes.

    The platform supports two scenarios:

    • Akamas Offline optimizes in staging by automating performance tuning against a load test
    • Akamas Insights optimizes directly in production, surfacing opportunities and issuing ready-to-apply recommendations for Kubernetes clusters and workloads

    This article focuses on Akamas Offline and the Speedscale integration.

    At its core, Akamas uses patented reinforcement learning. Long before large language models and the “agentic” labelling of everything, Akamas was already applying advanced AI to converge on strong configurations within hours of the first experiment.

    It is worth remembering what the manual version looked like. Performance engineers gathered in a lab with a production-like environment. They ran load tests by hand, read the results, changed one setting, and repeated. Weeks or months would pass. Now consider a Java application with 500+ JVM options, plus pod resources and scaling policies, for every microservice. Manual optimization is not slow. It is arithmetically impossible.

    Unlike code profiling, Akamas needs no code changes and no in-process agents. It reads KPIs from the observability tooling you already run, integrating with Dynatrace, Datadog and open source tools such as Prometheus. Reading telemetry rather than instrumenting the application keeps overhead minimal and leaves application behaviour undistorted, which matters when that behaviour is the training signal.

    What “autonomous” actually means here

    Autonomous means the optimization process runs against a goal you set. “Improve throughput.” “Reduce cost while holding my latency SLO.”

    Akamas applies or recommends configuration changes, evaluates the result, and converges on the configuration that meets the goal. Two operating modes are available:

    • Fully autonomous: changes are applied directly
    • Semi-autonomous: changes are issued as recommendations that a human approves

    What Akamas optimizes

    Optimization here means adjusting parameters across the whole stack rather than one layer of it.

    LayerExamples
    KubernetesPod CPU and memory requests and limits, replica counts, HPA settings
    Application runtimeJVM heap and garbage collection flags, Node.js runtime options
    InfrastructureCloud instance type and size

    Full-stack coverage is the point. Akamas tunes infrastructure-level and application-level settings in the same experiment, which is what makes the resulting changes reliable rather than locally optimal. We explain why single-layer tuning fails in full-stack optimization: more than just Kubernetes.

    Goal-oriented optimization with SLOs and guardrails

    Optimization is goal-oriented, so users define both the objective and the constraints. Objectives can be maximum application throughput, minimum cloud resource usage, or a balance across throughput, response time, resilience and cost. Tying the objective to a business outcome is what pulls performance engineering out of purely technical metrics.

    Guardrails matter as much as goals. An AI optimizing without boundaries will happily cut cost and destroy latency. Akamas learns continuously from system behaviour and rejects changes that would harm performance, cost or availability. Defining SLOs constrains the search to configurations inside acceptable performance boundaries, and safety policies prevent failures reaching production.

    Performance experiment orchestration

    Akamas runs performance experiments in a structured loop:

    1. Apply a configuration
    2. Trigger a test
    3. Collect metrics
    4. Evaluate the result against the goal
    5. Choose the next configuration to try

    Akamas acts as the brain of that loop, not as the load generator. Existing load testing investments still generate the workload, so teams keep best-of-breed tools rather than being locked into one methodology. This is exactly where Speedscale fits.

    Speedscale: production traffic replay and service virtualization

    Speedscale takes a different route to API and load testing. It isolates individual microservices so each component can be tested and tuned before release. For a complex application, tuning component by component is how you make sure the end-to-end experience rests on something solid.

    Speedscale runs a three-part process:

    1. Observe. Capture API requests and responses to build realistic data sets
    2. Transform. Prepare that data for replay in another environment
    3. Replay. Execute load tests and mocks against new versions of the code

    Capturing and replaying sanitized production traffic brings the messy reality of production into staging. You get deep insight into behaviour under realistic conditions, without risking live systems or exposing sensitive data.

    Realistic environment replication and service virtualization

    Traditional load testing tools cannot easily replicate the responses of a complex production environment and its dependencies. Doing that requires service virtualization, which Speedscale provides natively. It generates mock services automatically from the backend requests and responses captured during observation.

    Privacy is handled in the same step. Data sanitization options include PII masking, header filtering and custom scrubbers driven by regex or JSONPath rules.

    These mocks behave like production because they came from production. They refresh automatically from running systems and need no application changes and no network re-routing, which removes the maintenance burden and the result distortion that traditional mocks introduce.

    What Speedscale builds is closer to an environment replication system: it simulates the active parts of the runtime environment, including a remote Kubernetes cluster, Elastic Container Service (ECS), or a virtual machine environment.

    Mocking also decouples application code from downstream systems such as large language models and databases. That means testing at scale without hitting rate limits or paying per-transaction costs for real services. The full service virtualization toolkit is there, including artificial response delays so you can see how a slow external dependency ripples through the wider application. Load shaping lets you multiply captured traffic by 2x or 10x of expected production load.

    Solving the environment problem removes a large slice of the setup and configuration time from any load testing project.

    Performance insights and reporting

    The Speedscale Traffic Viewer visualizes traffic flows in real time. You can inspect API request and response payloads, headers and metadata, and filter or search to find specific patterns and anomalies.

    After a replay, reports cover the SRE golden signals:

    • Errors: a dedicated dashboard
    • Latency: average, 95th and 99th percentile
    • Throughput: requests per second or per minute
    • Saturation: CPU and memory utilization from the environment

    The Traffic Viewer also includes a Graphical Service Map built from actual traffic rather than from a diagram someone drew last year. It shows dependencies, bottlenecks and data flow, which makes failure points easier to pinpoint.

    Speedscale integrates with the major observability vendors in stand-alone mode too, so both platforms can read from the same telemetry stack.

    How the Akamas and Speedscale integration works

    Together the two products cover both halves of the problem. Speedscale supplies realistic input. Akamas decides what to change.

    ResponsibilitySpeedscaleAkamas
    Generate realistic workloadReplays sanitized production trafficTriggers the test as part of the loop
    Provide dependenciesAuto-generated service mocks, refreshed from running systemsNot applicable
    Measure the runLatency, throughput, error rate, resource utilizationIngests KPIs from observability tooling
    Decide the next configurationNot applicableReinforcement learning selects the next candidate
    Apply the resultTest case versioning, rollback safeguardsApplies or recommends the optimal configuration

    Speedscale generates realistic test cases and high-fidelity mocks from real traffic, which removes the manual maintenance that normally makes realistic dependencies unaffordable. Akamas then orchestrates the experiments, learns from each run, and recommends optimal configurations for Kubernetes resources, JVMs, Node.js applications and other components.

    The dependency runs in one direction and it matters. Akamas learns from measured performance data, so the quality of the learning is capped by the quality of the workload. Replayed production traffic raises that ceiling, because latency, throughput, error rates and resource utilization are all measured under conditions that mirror live production.

    Kubernetes performance testing in CI/CD

    Both products run inside a pipeline, which is where the loop actually closes:

    • Every code change is validated against realistic production traffic
    • Developers get immediate feedback on regressions and improvements
    • Speedscale supports test case versioning and rollback safeguards, and can block a merge when a replay degrades performance
    • Akamas applies its recommended configurations as a pipeline step

    The result is a performance gate that runs on every commit rather than a performance test phase that runs when someone has time.

    Where performance engineering goes next

    Performance engineering is moving toward autonomous, intelligent systems, pushed there by AI and machine learning. There is a lot of hype in this space right now. There are also real capabilities underneath it, and the gap is closing quickly.

    The direction is clear enough. Systems keep getting more complex, and human pace stops being sufficient. AI platforms spot subtle patterns and generate complex queries and candidate solutions faster than people can, which accelerates analysis and troubleshooting and spreads expertise beyond a small group of specialists. Teams get productivity back, and time for innovation with it.

    Shifting left was the first step: developers testing individual features under a handful of virtual users. Embedding performance testing and tuning directly in the CI/CD pipeline is the next one, so every change is validated against realistic conditions automatically.

    A continuous, AI-driven performance feedback loop removes the manual guesswork and the endless trial and error. Releases become more predictable and deployment risk goes down.

    Low-code and no-code interfaces are pulling test creation away from specialists too, so more roles can design and run performance tests without heavy scripting. Specialists are not going away. Someone still has to apply context across the full spectrum of enterprise performance. But the more roles that own performance inside their own scope, the better the outcome.

    Bottom line

    Speedscale and Akamas solve two halves of the same problem. Speedscale feeds Akamas realistic workloads and accurate performance data. Akamas orchestrates those tests and applies the resulting configurations inside CI/CD. Neither half works well alone: realistic traffic without automated tuning is just better measurement, and automated tuning on synthetic traffic optimizes for a workload that does not exist.

    Customers running Akamas optimization at scale have seen substantial results. Gaming operator Sisal cut the cost of its Kubernetes microservices by 58% (read the case study).

    Performance engineering stops being a reactive, bottleneck-prone phase and becomes a continuous process that runs on every commit.

    FAQs

    What is Kubernetes performance testing?

    Kubernetes performance testing measures how containerized workloads behave under load. It covers pod resources, autoscaling behaviour, application runtime settings and the dependencies between services. Unlike testing a monolith, it has to account for infrastructure that changes during the test.

    How is traffic replay different from traditional load testing?

    Traditional load testing runs a script that someone wrote from an assumed traffic model. Traffic replay captures real requests and responses from production and replays them. The workload is observed rather than guessed, so the results reflect what your users actually do.

    Do I need service virtualization for microservices performance testing?

    You need it whenever a service under test depends on something you cannot run in the test environment. That includes third-party APIs, LLM endpoints and production databases. Service virtualization stands in for those dependencies so the test is not blocked or billed per transaction.

    Can performance testing run in a CI/CD pipeline?

    Yes. Speedscale replays traffic against each build and can block a merge when performance degrades. Akamas runs its optimization experiments as a pipeline step and applies the recommended configuration. Both fit into an existing pipeline without a separate testing phase.

    Does Akamas require agents or code changes?

    No. Akamas reads KPIs from the observability tooling you already run, including Dynatrace, Datadog and Prometheus. There is no in-process agent and no application code change, so the measured behaviour is not distorted by the measurement.

    How does this differ from APM or Kubernetes monitoring?

    Monitoring and APM tools tell you what happened. They do not choose the configuration that fixes it. Akamas sits on top of that telemetry and turns it into specific configuration recommendations. It integrates with your existing monitoring stack rather than replacing it.

    About the author

    Scott Moore, Performance Engineering Advocate. More than 30 years in load testing and performance engineering, writing and speaking on how the discipline is changing in cloud-native environments.

    Want to see this on your own workloads? Calculate your Kubernetes savings or create an account.

  • Top 10 Kubernetes Performance Pitfalls (and how to avoid them)

    Top 10 Kubernetes Performance Pitfalls (and how to avoid them)

    If you are a cloud native company, you already know that Kubernetes is a solid choice for deploying and managing modern applications at scale. It’s flexible, powerful, and capable of handling complex workloads. However, there is also the potential for serious performance headaches.

    Many people think performance optimization is just about cutting costs or squeezing efficiency out of resources. That’s part of it, but not all of it. It’s also about delivering reliable services without over-provisioning. There is a fine line between balancing performance, reliability, and costs. Nobody wants a cheap Kubernetes environment if it’s always down (or slow). That only frustrates users. Nobody wants a robust Kubernetes environment that costs so much to run that it defeats the purpose.

    Kubernetes optimization is more than tuning the cluster (sorry, platform engineers). It’s a holistic effort that involves many layers, including the cluster, the workloads and application runtimes like the JVM running on it. Focusing on just one piece leaves significant optimization opportunities on the table. It’s a layered stack: the infrastructure (nodes, networking, storage), the control plane (scheduling, autoscaling), and the applications themselves. Each layer needs attention.

    In this article, we’re going to look at the top performance pitfalls that we see on a regular basis from customers in their Kubernetes journey. We’ll show you how to avoid these antipatterns and share practical tips to keep your deployments smooth.

    1. Settings CPU Limits Based on Theory Rather Than Experience

    By far, pod resource requests and limits are the biggest challenge K8s teams face. If you’re not familiar, we described how requests and limits work and their impact on costs and reliability in a previous post.

    One of the most debated aspects is CPU limits: is it best to set them for your workloads, or avoid them and just live with CPU requests? CPU limits can cause CPU throttling and significant application performance degradation, such as response-time slowdowns, even when CPU usage is low compared to the limit.

    But CPU limits can also be critical for cluster stability and application performance in shared or multi-tenant clusters. So, as a developer or operator of K8s apps aiming for reliability and efficiency, what should you do?

    To understand how CPU limits actually work, we ran performance tests under CPU-contention scenarios. We measured application performance when a misbehaving job, co-located on the same node, saturates the node CPUs. We tested two setups: CPU requests only (no limits), and both requests and limits set.

    The result? CPU requests alone do not protect latency-sensitive workloads from a noisy neighbor. In our tests, application p95 latency rose 3x. With CPU limits in place, the CPU-hungry job could no longer saturate the node, and the impact on application performance was contained.

    Why is that? This might sound counterintuitive, especially as many people expect CPU requests to prevent such situations. But there is nothing wrong here: that’s exactly how CPU resource management works on K8s (courtesy of Linux cgroups), and failing to understand it can have serious consequences for app performance and stability, as others have noted too. More details in an upcoming blog.

    2. Picking the Wrong Instance types for your Nodes

    Kubernetes provides built-in autoscalers at the cluster level, adding nodes when demand rises and removing them when traffic dies down. The Cluster Autoscaler (or Karpenter) watches resource requests from pending pods, spins up new nodes to accommodate them, then scales down during quiet periods to save costs.

    A common issue SREs and platform engineers face is failing to keep node-group configuration matched to workload resource requirements. Teams often configure node groups with standard cloud instance types and never revisit whether the CPU-to-memory (or GPU) ratio matches the workload shape.

    This can produce highly inefficient allocation at the cluster level, with significant CPU or memory (and cost) wasted. What often happens: the cluster autoscaler adds nodes for pending pods, but only one resource (say, memory) is exhausted while the other (say, CPU) sits idle and wasted.

    Let’s look at an example. In this cluster, the cluster autoscaler creates nodes due to a memory shortage (right chart). In doing so it provisioned roughly 5,000 CPUs that went unused, because the workloads never requested them (left chart).

    Notice that the cluster autoscaler works perfectly here. Nevertheless, a huge amount of resources and cost is wasted because of the poor instance-type configuration in the underlying node groups.

    Choosing node types and scaling your cluster is like picking the right rental car for a road trip. Too small, and everyone is cramped, with no room for luggage. Too big, and you burn far too much fuel, and every gas-station stop leaves your wallet in shock. Misjudge your node instance types, or fail to scale dynamically, and you’ll either hit bottlenecks or waste a lot of resources.

    3. JVM Misconfigurations for Java Applications

    Java applications on Kubernetes can be particularly tricky. The Java Virtual Machine (JVM) is a highly configurable engine with 500+ options that can be tuned for performance and resource efficiency. But JVM tuning requires deep expertise and is notoriously hard. Even a common task like determining the optimal heap memory size can be surprisingly complex for Java developers.

    Containers and Kubernetes add another layer of complexity: how should you configure the memory limit and heap size of your JVM? And what about CPU limits and garbage-collector type? For high-performance, reliable, efficient Java apps, JVM resource management must be aligned with Kubernetes pod resource settings. Despite the JVM’s container-aware heuristics, in practice the default configurations are wasteful, prone to reliability issues, or cause unnecessary slowdowns.

    Here’s a real example. In the chart below you can see an out-of-memory kill (OOMKill) that hit application availability. Seeing the steady rise in container memory usage, the SRE team blamed a memory leak in the application – time to fix your code, dear development team! But there was no memory leak. The real cause was a JVM misconfiguration: the pod memory limit did not account for total JVM memory demand, which includes both heap and off-heap memory.

    4. Poor application performance due to wrong JVM heap sizing

    In the previous pitfall we covered jointly optimizing pod resources and the application runtime to avoid reliability issues. But a wrong JVM configuration can hurt application performance too.

    Many developers assume the JVM performs best out of the box, especially with container-awareness features that let it size the heap automatically from pod memory limits. In reality – whether you set the heap explicitly (e.g. via -Xmx) or rely on container awareness (e.g. MaxRAMPercentage) – the resulting heap size may be well off and slow your application substantially.

    To show this, we ran benchmarks with the DaCapo Java suite, which mimics real-world Java workloads. We used the G1 garbage collector on Java 21 (eclipse-temurin) and measured Spring Boot latency across different JVM max-heap sizes. Here’s what we found:

    • If the heap is too small, performance suffers badly. A 20% latency impact is easy to hit, rising to 65% when the heap is too tight.
    • Beyond a certain size, more heap doesn’t help. Throwing gigabytes of memory at a Java app is not useful – the extra memory is basically wasted.

    As a Java developer looking to optimize your applications and microservices, don’t forget to size your JVM heap properly.

    5. Resource Management for Node.js Applications

    Node.js applications often hit performance and reliability issues on Kubernetes because of their unique (and, honestly, under-documented) runtime characteristics.

    Node.js runs on a managed runtime called V8, which resembles the JVM in many ways, including automatic memory management via garbage collection and a multi-threaded architecture (yes – the Node.js runtime is not single-threaded).

    A common problem is an out-of-memory kill (OOMKill). This mirrors pitfall #3 for the JVM: most teams misread OOMKills as a memory leak, when the real issue is how heap memory is sized relative to container memory limits.

    Less known is that Node.js performance and resource usage are also very sensitive to V8 garbage collection and heap settings. In an earlier blog we benchmarked a Node.js app across different V8 heap-pool sizes. Tuning the V8 heap memory pools cut application latency by nearly 50%, with no code changes. Similar gains showed up on CPU usage – which means savings on infrastructure footprint and cost.

    Check the blog for full details.

    6. Misconfigured HPA Autoscaling (Autoscaling Gone Wild)

    Kubernetes provides built-in application-level scaling via the Horizontal Pod Autoscaler (HPA), adding pods when demand rises and removing them when traffic dies down. HPA can be a lifesaver, but it’s not a set-and-forget solution.

    HPA needs careful tuning of scaling metrics, thresholds, and periods. Scaling behaviour is highly application- and traffic-dependent. Is your app’s startup time quick or slow? Do you need to react to sudden traffic peaks, or does traffic build slowly? Depending on your performance requirements or SLOs, HPA must be configured accordingly.

    Teams often don’t get HPA right, and we regularly see deployments that scale too slowly, too aggressively, or fail to scale down. A poorly tuned HPA will:

    • hurt end-user performance
    • cause unnecessary SLO breaches and production incidents
    • waste a lot of resources
    • push the cluster autoscaler to provision unnecessary nodes

    Look at this example. The team rightly adopted HPA for a deployment with fluctuating traffic, but set the scaling threshold far too low. As a result, HPA scaled the deployment far too much: overall HPA scaling efficiency (CPU used / CPU requested) was just 9%, wasting most of the requested CPU.

    The lesson: as with cluster-level autoscaling, simply adding HPA to your workloads may not meet the scalability and efficiency goals you’re after.

    7. VPA Missteps with Requests and Limits

    The Vertical Pod Autoscaler (VPA) is often the most recommended tool for setting pod resource requests and limits. VPA automatically sets container requests and limits based on observed usage.

    That sounds like exactly what’s needed, but the reality is different.VPA has a number of known limitations that many teams are not aware of, and can make it inapplicable in real-world production environments.

    There is one very important limitation not even mentioned in the docs. The VPA recommendation algorithm takes a purely infrastructure-only approach: it looks at resource usage and adjusts resources, with no awareness of the application running inside the pod.

    Why is that a problem? Modern apps run on a runtime that manages resources such as heap memory and CPU threads. Runtimes like the JVM or Node.js V8 adjust automatically based on pod resource limits. The VPA is unaware of how these runtimes behave, so applying its recommendations without care can create performance and reliability issues.

    Infrastructure-only approaches like the VPA can also slow your application down. In one customer test, the team applied VPA recommendations to a Java app and measured response time before and after. The change introduced significant slowdowns, making the app unresponsive to users.

    Why did that happen? Read this blog on why it’s crucial to consider the application runtimes inside containers and why infrastructure-level metrics aren’t enough. This holds for any tool or approach that looks only at container-level resource metrics – not just the VPA.

    8. Pod Sizing for Disaster Recovery (DR) and High Availability (HA)

    Poorly sized pods in disaster-recovery or high-availability scenarios can jeopardize cluster resilience. If pods aren’t configured to handle failover or spikes, you risk downtime or degraded performance during critical moments.

    This is a common challenge for SREs and development teams working out the best resource-allocation strategy. Teams typically size pods against currently observed load. For example, a pod requests 4 CPUs but uses just 1, so you downsize it to match the 1-CPU demand and save cost.

    The problem: this ignores reliability, high availability, and business-continuity requirements. Your applications may need to withstand the failure of one or more data centers and keep response times good during infrastructure disruptions.

    Properly sizing workloads for degraded scenarios means simulating the impact of 2x traffic on your workloads. And again, it’s not only about pod resources: your application runtime – like the JVM heap memory – must be considered too, to avoid unexpected bottlenecks at critical moments.

    9. Configuration Chaos and Drift

    Technical issues aren’t the only challenges teams face adopting Kubernetes. A more organizational or process issue we see, especially in mid-to-large organizations, is that developers push frequent changes to production, and these can introduce performance regressions or outright break things across the cluster.

    Part of the problem is that developers aren’t necessarily well-versed in the Kubernetes stack – and rightly so. As we showed in this blog, configuring apps and clusters for efficiency and performance is no small feat. Developers’ goal is usually to ship features quickly, not to become infrastructure experts.

    Meanwhile, SREs and platform engineers have to cope with the fallout. Poor configuration of even a single workload can impact other applications on the same node (as shown in pitfall #1 on CPU limits) or the entire cluster (for example, if a node crashes).

    Kubernetes is a great platform, but every user has to be a good citizen and use it wisely so everyone else can too. At scale, proper performance isolation and reliability practices are key – and in practice this doesn’t always happen. The only way to keep the platform stable, performant, and efficient is to adopt proper processes and tools that automate the optimization work as you scale.

    10. Organizational Knowledge Gaps and Prioritization Conflicts

    Kubernetes thrives on collaboration, but when priorities aren’t aligned between platform engineering and application teams, it creates a deadlock that affects both performance and reliability. When application teams lack Kubernetes expertise and prioritize feature speed over stability, big problems follow.

    It typically goes like this:

    • Platform engineers understand Kubernetes intricacies, but application teams may lack the training to optimize their deployments. This leads to misconfigured resources or ignored best practices.
    • Application teams focus on shipping features quickly, sidelining critical tasks like performance tuning, monitoring setup, or adopting Kubernetes-native practices.
    • Without good collaboration, platform teams may enforce overly restrictive policies while application teams deploy suboptimal workloads. The result is friction between teams and unreliable software.

    To fix this, invest in cross-team training to bridge the Kubernetes knowledge gap. Offer workshops or hands-on learning tailored to application teams. Establish clear service-level objectives (SLOs) that align platform and application priorities, balancing feature velocity with reliability goals.

    Tools to Save the Day

    Here are some tools and techniques to help you tune Kubernetes for better performance:

    • Observability: Use tools like Prometheus, OpenTelemetry, or commercial options like Dynatrace and Datadog to understand resource usage. Don’t stop at workload-level metrics – collect application-runtime metrics too, as they are critical for success, as shown throughout this post.
    • AI-powered tuning: Use tools that automate full-stack Kubernetes optimization to reduce the effort and skills required from engineering teams. Akamas autonomously optimizes the full-stack configuration of enterprise applications – from infrastructure to application layers – using reinforcement learning, live telemetry, and user-defined goals, both live in production and offline in testing.
    • Load testing: Simulate traffic with tools like Locust, JMeter, or commercial options like OpenText LoadRunner and Tricentis NeoLoad. Load testing is often the best way to find scalability bottlenecks and tune workload configurations like the JVM or HPA before you deploy to production.
    • Chaos engineering: Use tools like Chaos Toolkit, Chaos Mesh, or commercial options like Gremlin to test resilience against worst-case events. This helps confirm applications can sustain traffic in disaster-recovery scenarios.
    • Advanced Kubernetes features: Use capabilities like taints, tolerations, affinity rules, priority classes, resource quotas, and HPAs to build reliable, efficient clusters.

    Wrapping It Up

    Kubernetes is a great platform to scale your cloud applications on, and we love it – but performance and efficiency won’t come for free. You can build clusters that are fast, reliable, and cost-effective by avoiding these common pitfalls. The key is to stay proactive: monitor relentlessly, tune continuously, and build a performance-engineering culture where everyone cares about performance within their own scope.

    If you’re struggling with Kubernetes performance, we can help. Explore Akamas Insights to see how our AI-driven optimization platform tackles all of these challenges and cuts cost. We understand the problems companies face deploying Kubernetes at scale, and we can help you too.

    FAQs

    What causes poor performance in Kubernetes?

    Most Kubernetes performance problems come from small misconfigurations across three layers: infrastructure (node instance types), the control plane (HPA, VPA, cluster autoscaler), and the application runtime (JVM or Node.js/V8). Optimizing one layer while ignoring the others leaves gains on the table and can even create new bottlenecks.

    Do CPU limits help or hurt Kubernetes performance?

    Both, depending on context. CPU limits can cause throttling and slow a workload even when usage looks low. But in shared or multi-tenant clusters they protect latency-sensitive workloads from noisy neighbors. In Akamas contention tests, removing CPU limits let a misbehaving job push p95 latency 3x higher.

    Why do Java applications get OOMKilled on Kubernetes?

    Usually not because of a memory leak. The common cause is a pod memory limit that doesn’t account for total JVM memory demand, which includes both heap and off-heap memory. When off-heap usage is ignored, container memory grows past the limit and Kubernetes issues an OOMKill.

    Does the Vertical Pod Autoscaler (VPA) improve application performance?

    Not reliably. The VPA sets requests and limits from observed infrastructure usage alone, with no awareness of the runtime inside the pod. Because runtimes like the JVM and V8 react to pod limits, applying VPA recommendations blindly can slow an application down, as seen in a customer test on a Java app.

    How do you optimize Kubernetes performance across the full stack?

    Tune pods, application runtimes, and nodes together instead of in isolation. Align JVM or V8 settings with pod resource limits, size node instances to workload shape, and validate autoscaling under realistic traffic. Automating this full-stack tuning – for example with Akamas – reduces manual effort and keeps configurations optimal as workloads change.

  • Application Performance Optimization on Kubernetes: More Than Just Pods

    Application Performance Optimization on Kubernetes: More Than Just Pods

    In 2025, Kubernetes dominates the cloud container landscape. It is the “operating system of the cloud.” Yet many organizations are discovering how expensive it is to run and scale. OOM kills anyone?

    Application performance optimization on Kubernetes usually stops at pod requests and limits. That misses the layer where most waste and most reliability risk actually live: the application runtime. Tuning the JVM, Node.js V8, .NET CLR, or Go runtime alongside pod and node settings is what turns Kubernetes cost and reliability around.

    Overprovisioning to avoid an outage costs companies far more than they budgeted when they first migrated to containers. Many teams right-size pods and tune cluster resources to fix it. Most still miss the fundamental layer that holds the key to poor reliability and overspending: the language runtime of the application itself. As a result, they leave money on the table and suffer avoidable reliability incidents.

    Modern applications do not run directly on Kubernetes. They execute on language runtimes like the Java Virtual Machine, the Node.js V8 engine, the .NET CLR, or the Go runtime. None of these is “tuned” out of the gate. Each exposes an intimidating number of options for memory allocation, garbage collection, thread management, and compilation. Each setting can make a large difference in performance and resource use. This area gets ignored because the platform teams that deploy the applications focus on Kubernetes, not on the applications themselves.

    Chart showing Java 21 exposes 537 JVM configuration options for memory, GC, threads, and compilation
    Java 21 has an outstanding 537 configuration options. How many are you actually setting?

    The Hidden Costs of Pod-Only Kubernetes Optimization

    The main approach SREs and platform teams use today is tuning pod requests and limits. That instinct is right, because applications are where most of the waste comes from. The execution is misguided. It looks only at Kubernetes metrics like pod-level CPU and memory. What happens inside the application is treated as someone else’s problem.

    Tuning at that level is genuinely hard. The right configuration is specific per application and demands a granular view. Focusing on infrastructure alone produces three problems we see as a pattern at Akamas.

    Memory Misconfiguration Leads to Cascading Failures

    Consider a typical Java application in a Kubernetes pod. Infrastructure monitoring shows the pod steadily uses 2GB, so a tool recommends cutting the limit from 4GB to 2.5GB for savings. That recommendation ignores the JVM heap configuration, which may be set to use up to 3GB based on the original 4GB limit.

    The result? A slight traffic increase pushes the JVM to use all the allocated heap, and Kubernetes kills the pod. These reliability problems are invisible in infrastructure metrics until it is too late.

    Diagram of a Kubernetes pod getting OOMKilled when the JVM heap exceeds a reduced pod memory limit

    Auto-Configuration Creates Performance Cliffs

    Java’s runtime reacts to your pod resources. Reduce a pod’s allocation and the runtime adjusts its own parameters. The JVM shrinks the heap, changes garbage collection behavior, and modifies thread pool sizes.

    These automatic adjustments often create problems. A slightly smaller memory limit can shrink the JVM heap. That triggers far more frequent garbage collection, which burns CPU and raises latency. The Node.js V8 engine behaves the same way. Memory pressure there can cause dramatic swings in resource use and execution performance.

    Diagram showing a smaller pod memory limit forcing a smaller JVM heap and more frequent garbage collection

    Efficiency Gains Require Runtime Tuning

    Right-sizing infrastructure removes some waste. It does not make the application more efficient. True efficiency comes from optimizing how the runtime uses resources. Developers routinely set Java heap far higher than the application needs. Properly sizing the heap can cut the memory footprint in half, with the same performance. Different garbage collection algorithms in the JVM can vary CPU usage by 30% for identical workloads. The default V8 settings are tuned for browsers, not for the high-throughput server workloads that Node.js runs.

    Tune the runtime parameters and you often get the same performance with far fewer resources. You can also get more performance from the same allocation. Sometimes the result shows up as a welcome drop on the monthly cloud invoice. This level of optimization is impossible without understanding the application layer.

    Chart showing lower monthly cloud cost after tuning application runtime memory and garbage collection

    How Runtime Config Breaks Kubernetes Autoscaling

    Optimization gets harder once Kubernetes autoscaling enters the picture. Horizontal Pod Autoscaling acts on the metrics and thresholds you define. If the runtime is poorly configured and out of step with pod requests and limits, these systems scale wrong. You get an excessive pod count that triggers unnecessary cluster scale-out, or under-provisioning that degrades performance.

    Diagram of Kubernetes HPA and cluster autoscaler scaling incorrectly because of a misconfigured application runtime
    There’s more to Kubernetes scaling than meets the eye.

    Node selection is another challenge. Should the workload run on compute-optimized instances with a high CPU-to-memory ratio, or memory-optimized instances with more RAM per core? The answer depends on the workload’s resource shape, which is driven mainly by the runtime configuration. Kubernetes cluster autoscalers can match provisioned resources to requests. Turning one on is not enough on its own. Your node group configuration is what makes node shapes match your workloads.

    Multiply these decisions across hundreds of microservices, each with different runtime needs and resource patterns. Manual optimization is not practical at that scale. When automated tools ignore the application layer, that blind spot guarantees overspending and reliability incidents.

    Beyond Infrastructure Metrics: Application-Aware Optimization

    Application performance optimization requires analyzing application metrics alongside infrastructure utilization. That means response times, throughput, error rates, garbage collection frequency, and more. You need the application-layer context that infrastructure metrics alone cannot give you.

    This is why application-aware optimization is essential to any sound Kubernetes optimization strategy. It also enables real collaboration between platform engineering, SREs, and developers, which produces more efficient and more reliable applications.

    An optimization tool that sees both layers at once shows you what you have been missing. A pod can show low CPU at the infrastructure level while suffering high garbage collection overhead that consumes CPU cycles inefficiently. A traditional tool recommends cutting CPU. An application-aware tool fixes the garbage collection stress instead.

    The payoff is that you improve cost efficiency and application performance together. You stop choosing between saving money and holding performance. You get both.

    The Path Forward: Full-Stack Performance and Cost Gains

    Organizations that use Akamas consistently report significant improvements, sometimes dramatic ones. In Akamas customer engagements, cost reductions of 20-50% are common when application tuning is combined with infrastructure optimization. Misconfigurations that cause reliability issues get identified and fixed fast. Performance gains often exceed the cost savings, with response-time reductions of 30% that are not uncommon. Akamas often pays for itself in the early stages of tuning.

    Instead of fighting resource constraints and performance issues, teams can proactively tune their specific Kubernetes environment for their own applications. Teams that adopt application-aware optimization end up with more efficient, more reliable, and more cost-effective Kubernetes deployments.

    Ready to see how much performance and cost your Kubernetes applications are leaving on the table? Learn more about full-stack optimization for your organization.

    FAQs

    What is application performance optimization on Kubernetes?

    It is tuning the application runtime, the pod settings, and the cloud nodes together, not in isolation. Most teams tune only pods. This approach also tunes the JVM, V8, or .NET CLR the application runs on, which is where much of the waste and reliability risk lives.

    Why is pod rightsizing not enough to reduce Kubernetes cost?

    Pod rightsizing looks at pod-level CPU and memory, not at what happens inside the runtime. A pod can look efficient while the JVM wastes CPU on garbage collection. Rightsizing alone can also shrink the heap and trigger OOM kills. Runtime tuning is what removes the underlying waste.

    What happens to the JVM when you lower a pod’s memory limit?

    The JVM reacts to the resources it sees. A smaller limit shrinks the heap, which can trigger far more frequent garbage collection, higher CPU use, and increased latency. Below a threshold, the pod gets OOMKilled. This is why heap settings must be tuned together with pod limits.

    How much can runtime tuning reduce Kubernetes cost?

    In Akamas customer engagements, combining application tuning with infrastructure optimization commonly cuts cost 20-50%. Properly sizing the JVM heap alone can halve the memory footprint at equal performance, and choosing the right garbage collector can shift CPU usage by around 30% for the same workload.

    Which application runtimes can be optimized this way?

    The same approach applies to the Java Virtual Machine, the Node.js V8 engine, the .NET CLR, and the Go runtime. Each exposes many options for memory, garbage collection, threading, and compilation. Java 21 alone has 537 configuration options.