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

by Mario Scriminaci

October 29, 2026

Share this post

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.

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

See for Yourself

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