Skip to content

Savings

FinOps → Cost & savings → Savings answers two questions for the selected cluster: how much could it save, and where?

Nothing on this page changes your cluster by itself. Apply selected sends what you ticked for approval, and nothing happens until someone approves it. If you would rather Seylo applied the savings for you, inside limits you agree to, an admin can switch on managed savings.

Cost and Savings share the figures Seylo worked out recently, so moving between them, and opening them again, does not start the work over. A line near the top says how old they are: Figures from 3 min ago · Refresh. Seylo reuses figures for up to 5 minutes. Refresh works them out again now. The tabs of Cost & savings stay loaded while you move between them, so a tab you return to is as you left it.

The card at the top shows:

Figure What it is
$ /mo What the ticked levers would save each month
$ /yr The same, times twelve
% That saving as a share of what the cluster’s nodes cost today

Tick or untick a lever below and the total changes at once.

The figures are compute only: what the nodes cost. Storage, network traffic and discounts you already hold are not in them.

The page is worked out from a fresh read of the cluster and kept for 5 minutes; Worked out shows when. Refresh reads the cluster again.

If a ticked lever has no price, the headline reads at least $X. If none of the ticked levers has a price, it reads Not priced. Seylo never fills a gap with an estimate from a similar machine; the lever says why it has no price instead.

The badge beside the title says who applies savings on this cluster:

Badge Meaning
Read only Seylo only proposes here. Every change goes through Approvals. An admin sees Let Seylo manage savings beside it
Managed Seylo applies the levers an admin switched on, inside the grant they signed. See managed savings
Stopped, Expired, Paused Managed savings was switched on and is not acting now; the panel under the headline says why

Under the headline, one sentence states the whole plan, for example: Right-size 8 workloads, then remove 1 of pool user’s 3 × Standard_D4as_v6: about 25% of what the nodes cost, $120.00 a month. It is one figure, not three separate ones, because the steps depend on each other: lowering a request saves nothing until a node can go.

Below it are the steps, in the order you would do them. Select a step to see where its number comes from.

Step What it is Its share of the figure
1. Right-size Lower requests on workloads that ask for much more than they use The dollars that exist only because requests went down: the cluster packed with the smaller requests, compared with the cluster packed with today’s
2. Fewer or smaller nodes Remove nodes, or replace them with a smaller size, once the pods fit What packing today’s requests tighter would save; the node change the whole plan ends with is stated in the line
3. Spot (optional) Move safe workloads to spot nodes Shown beside the figure, not in it, and marked not in the figure. The line under the steps says what the figure becomes with spot, for example With spot for 4 workloads as well: about 30% of what the nodes cost, $150.00 a month. Tick Spot below to include it

The steps in the figure add up to it exactly. Each is the difference between two whole packings of the cluster, never a sum of estimates. A step with no price reads Not priced and says why, and a figure with an unpriced part reads at least.

The figure is what this cluster can reach safely, and Seylo does not stretch it to look larger. Two rules hold it, and the steps state them:

  • Right-sizing keeps headroom. A lowered request is the busiest 5% of use over 7 days plus the headroom your right-sizing rules sets, never below that 5% level. Memory is not lowered after an out-of-memory kill, and a raise is never counted as a saving.
  • Every node keeps 20% spare. Pods are packed onto each node with 20% of its CPU and memory left free after its node agents, and every pool keeps at least one node.

A tool that packs nodes tighter, or lowers requests to average use, can show a bigger number. Seylo’s figure is the one that leaves your workloads room.

Two things are named as not counted in step 1, because Seylo cannot send them:

  • StatefulSets and other workloads that are not Deployments. Seylo’s right-sizing change is made on Deployments. The step says how many such workloads could free more, and how much, so you can change them in their own manifests.
  • The cloud’s own add-ons, for example the managed Prometheus an AKS cluster runs in kube-system. Their manager puts their requests back, so a lower request would not last. See what keeps a node, and what does not.

Four levers, each with a checkbox, one line, and its saving in $ /mo and %. Select a lever’s arrow to open its detail.

Lever What it does Ticked at first
Fewer, better nodes Packs your pods onto fewer nodes, or onto a cheaper machine size, with 20% of each node spare Yes
Rightsizing Lowers requests that are well above what workloads use, and raises a limit a workload presses on Yes
Spot for safe workloads Moves workloads that can be interrupted to cheaper spot nodes No
Schedule Switches a non-production cluster off outside the hours you pick Only for a cluster marked non-production

Seylo works out what the cluster would cost with its pods packed onto the right machines, and compares that with what it costs today.

Each combination of ticked levers is worked out as a whole, so any mix you tick has its own total and no dollar is counted twice. The headline is the combination you ticked; the plan above it is the first two levers, then spot beside it. A lever’s own row shows what it adds after the rows above it, in this order: Fewer, better nodes, Rightsizing, Spot, Schedule.

Rightsizing and Spot save money only by packing the pods again, so ticking either one also ticks Fewer, better nodes. Unticking Fewer, better nodes unticks both.

A lever at $0 always says why, in its line. The reason comes from the same packing that worked out the figure, never from a guess:

The line says What it means
No node can go: every node runs a pod that cannot move (...) - see Cannot move below. Pods that cannot move are what keeps the nodes. The kinds are counted in the brackets, for example 3 with no controller, 1 on hostPath. Seylo packed the cluster again with those pods cleared, and it would save more: see Cannot move
No node can go: ... with a reason about a pool That pool was not packed again: its node agents ask for all of a node’s CPU or memory, or one pod asks for more than any size holds after its node agents. The pod or pool is named
The cluster already runs a single node. or Each pool already runs a single node. Every pool keeps at least one node
Requests fill every node: CPU is the limit, with 20% kept spare. The pods’ requests need every node. The resource nearest its limit is named: CPU, memory, or pods per node
Frees 3.2 vCPU and 6.0 GiB, not yet a whole node: ... Rightsizing frees capacity, but not a whole node yet. A smaller request only reaches your bill when a node goes
Frees ..., but every node runs a pod that cannot move - see Cannot move below. Rightsizing would free a node if the pinned pods could move
Spot would only add nodes for the ... safe workloads: ... - see Cannot move below. Moving the safe workloads to spot would not let any on-demand node go, because of the pods that cannot move
A spot pool for the ... safe workloads would cost more than it saves at this size. A spot pool of its own would cost more than the on-demand capacity it frees
No spot pool for the ... safe workloads is cheaper at this size. No spot size with a price is cheaper than what they run on today

Only these keep a node where it is:

  • a running pod with no controller to recreate it;
  • a pod marked cluster-autoscaler.kubernetes.io/safe-to-evict: "false";
  • a pod marked karpenter.sh/do-not-disrupt;
  • a pod that keeps data on the node (a hostPath that holds data).

These no longer keep a node:

What Why
A finished pod, such as the pod of a completed az aks command invoke It is not running, so nothing has to move. Seylo reads its state from the cluster and, where the agent does not send it, from the metrics store’s pod status. A pod whose state Seylo cannot tell stays unknown and is never assumed finished: its line says to upgrade the agent to 0.2.16 or later
The cloud’s own add-on under a controller, for example ama-metrics in kube-system on AKS The cloud’s add-on manager drains and recreates it on every node image upgrade anyway. Seylo recognises it by the labels the cloud puts on it: kubernetes.azure.com/managedby: aks or addonmanager.kubernetes.io/mode (and their EKS and GKE equivalents). One you marked safe-to-evict false or do-not-disrupt still keeps its node
A read-only mount of something every node provides: the node’s container logs, CA certificates, zone information, /proc or /sys Reading what every node already has does not tie a pod to one node. It must be read-only in every container of the pod. A writable /var/log mount still keeps the node. The agent works this out in your cluster and sends only the verdict, never the path. It needs an agent newer than 0.2.22: with 0.2.22 or older, such a mount is still listed as hostPath and keeps its node

A running pod with no controller still keeps its node, as before.

Whenever pods that cannot move keep nodes, a Cannot move list appears under the levers, without opening any of them. A pod cannot move off its node when it has:

Cause The line says What to do
No controller to recreate it shop/debug-pod has no controller to recreate it Delete it if it is not needed, or run it under a Deployment
cluster-autoscaler.kubernetes.io/safe-to-evict: "false" ... is marked safe-to-evict: false Remove the annotation from the workload if it may move
karpenter.sh/do-not-disrupt ... is marked do-not-disrupt Remove the annotation from the workload if it may move
Data on the node itself (hostPath), other than the read-only mounts listed above ... keeps data on the node (hostPath /var/data) Keep that data on a volume instead, so it can move

Each line names the workload and the nodes it holds, and what to do. The list shows the first six; Show all shows the rest.

Above the list, one sentence says what clearing them would be worth, from the same packing:

  • Clearing them adds $X/mo to the ticked rows.
  • They keep their nodes, but clearing them would not save more today.
  • What clearing them saves is not priced: a pool has no price.

The figure at the top already keeps their nodes: it is what you can save today, with those pods where they are.

Clear first is different. Those pods can move, but would block the autoscaler today: a system pod with no PodDisruptionBudget, or a PodDisruptionBudget that allows no disruption. They do not stop the saving. They are listed in the Fewer, better nodes detail, each with what to do and how many nodes it unlocks, and the lever’s line says so, for example “2 of 4 nodes can go once 3 system workloads get a PodDisruptionBudget”.

Every running pod’s requests are packed, largest first, onto as few nodes of its pool as hold them, with 20% of each node spare. DaemonSets are counted on every node, and every pool keeps at least one node. Only a pod that cannot move keeps its node where it is.

Each pool also tries other machine sizes. A size counts only if it holds the pool’s largest pod plus its DaemonSets, has a list price, and the cloud says your account can get it (see sizes your account can get). A repack that would cost more than today is never proposed.

A pool can come out with two sizes: up to three of its current nodes kept beside a smaller one, when that costs less than replacing them all at one size.

Cloud Sizes tried Priced from
Azure The D, E and F series. B sizes only for a pool already on B The Azure Retail Prices API
AWS The m5 to m7, c6 to c7 and r6 to r7 families. t sizes only for a pool already on t The AWS Price List. A size not yet in Seylo’s price book is fetched in the background and left out until it arrives; the page says so
Google Cloud E2, N2, N2D, N4, C3, C3D and T2D. T2A only for an arm64 pool Google’s Cloud Billing Catalog

A pool stays on its own CPU architecture. Seylo does not read your images, so it cannot know every image runs on Arm: Arm sizes (Azure “p” sizes, AWS Graviton, Google T2A) are offered only to a pool already on arm64, and an arm64 pool is offered only Arm sizes. Burstable sizes are offered only to a pool already on them: CPU credits are a choice for the pool’s owner.

How much of a node your pods can use is worked out per cloud: on AWS and Google Cloud, from the provider’s published reservations for the node’s system, plus whatever your pool reserves beyond them today.

When your current nodes are priced from your cloud bill and a different size is proposed, both are compared at list price: your bill may hold a discount that the new size would not get, and comparing a discounted price with a list price would make the saving look larger than it is. How this is worked out says when that happened.

A price list says nothing about whether your subscription, account or project may create a size here. So before a size is offered, Seylo reads your cloud account, read-only, and drops a size the cloud says no to:

Cloud What is read
Azure The subscription’s Resource SKUs for the region (a size restricted for your subscription, or not offered there) and its vCPU quota: the size’s family, the regional total, and for spot the separate spot (low-priority) vCPUs
AWS Which instance types are offered in the cluster’s zones, and the vCPU quotas for running On-Demand and Spot Standard instances (A, C, D, H, I, M, R, T, Z) with their current use. Other instance classes are not read, and their sizes say “not checked”
Google Cloud The region’s CPU quotas (all CPUs, the machine family’s, and preemptible CPUs for spot) and the machine types listed in each zone

Zones matter. A size can be restricted in some zones of a region and not others. Seylo reads where the pool’s nodes run, from their topology.kubernetes.io/zone labels, and judges the size against those zones:

  • Azure: a size restricted only in some zones is dropped only if the pool runs in those zones. A pool whose nodes are not zonal is not affected by a zone restriction, and the size is kept with a note. A restriction for the whole region always drops it.
  • Google Cloud: a machine type must be listed in every zone the pool runs in. A zone that could not be read is named.
  • AWS: instance offerings are read for the cluster’s zones.

The Fewer, better nodes detail says what was checked, and when: Sizes checked against this subscription's quota in eastus, ..., then what was left out and why, for example Left out: Standard_D8as_v5 - Quota: 4 of 100 vCPUs left for standardDASv5Family in eastus; one Standard_D8as_v5 needs 8., and what was kept despite a zone gap, for example Kept: Standard_D4ds_v6 - Not offered to this subscription in zone(s) 3 of eastus; this pool's nodes are not zonal, so that does not apply.

A size that passes is only “the cloud did not say no”: a launch can still be refused. A size that could not be checked stays on the page, labelled Availability and quota not checked - connect the cloud account (Integrations > Cloud accounts).

The detail also says which node autoscaler the cluster runs, read from the cluster: AKS node auto-provisioning, Karpenter, EKS Auto Mode, a GKE ComputeClass or node auto-provisioning, the classic cluster autoscaler, or none. Where nothing that can remove empty nodes runs, it shows the one command that turns one on, with what to check before you run it. Seylo only shows the command; it never runs it. Reading the autoscaler needs agent 0.2.21.

The detail also holds the Clear first list, the nodes that stay and why, and the node reduction plan.

Rightsizing judges each container’s CPU and memory once, in one direction:

Row When What it changes
Raise The container presses on its limit: CPU’s busiest 5% at 90% of its CPU limit or more, or throttled; or memory’s peak at 90% of its memory limit or more, or an out-of-memory kill The limit, up. CPU goes up one 50% step: use cannot be measured above the limit, so how much more it wants is not known. Memory goes to 1.5 times its peak, or one 50% step after an out-of-memory kill, and always above the peak
Lower The request is well above what the container uses, and it is not at risk. For memory, nothing was killed for running out of memory in the window The request, down: the busiest 5% of use plus headroom, never below that 5% level

Never both for the same resource. A container pressing on its limit is not lowered at the same time: at risk wins, because lowering the request of a container already short trades an outage for a saving. CPU and memory are judged separately, so raising one container’s memory limit while lowering its CPU request is not a contradiction.

A raise is not a saving, and has no dollar figure. A limit reserves no node capacity, so the bill moves only if the container then uses more. Raise rows are listed above the lowers, each with what put it at risk, for example Memory peaked at 470Mi, 92% of its 512Mi limit. When any exist, a line under the levers says how many workloads are pressing on a limit. Send for approval sends one raise on its own.

The saving comes from the lowers, by packing the pods again with the smaller requests: the nodes they free beyond Fewer, better nodes. A smaller request only reaches your bill when a node goes, so rightsizing can read $0; see when a lever reads $0.

The detail holds the full list: raise, right-size, idle workload, unused volume, unclaimed volume and idle load balancer, each with its evidence. The rules behind each recommendation are on right-sizing and usage evidence.

Seylo’s right-sizing change is made on Deployments. A StatefulSet, and any other workload that is not a Deployment, can ask for more than it uses too: the plan lists them as not counted, with what they could free, and you change them in their own manifests. The cloud’s own add-ons in kube-system are not counted either, because their manager resets them.

Rightsizing is the only place Seylo sizes containers for cost. Nightshift still raises sizes when an alert calls for it; see autoscaler or a bigger request.

A workload is safe on spot when it is a Deployment with:

  • 2 or more running replicas;
  • no persistent volume;
  • no local disk it has not marked as disposable;
  • no opt-out from eviction;

and it is not in a system namespace. A workload with no PodDisruptionBudget still counts; the spot task includes adding one.

The detail lists every workload, safe or not, with the reason.

The safe pods are packed onto spot nodes of the cheapest size that has a spot price and holds them; everything else stays on on-demand nodes, sized again for what is left. The saving is the difference from the row above.

Cloud Spot price
Azure Azure’s public spot list price for the machine and region. Where Azure shows more than one, the higher one
AWS Read through your connected AWS account’s read role from EC2’s spot price history, Linux, for each of the cluster’s zones; the highest current price among them is used. A zone with no price does not sell that size on spot, and is named. A zone whose newest price is more than 30 days old leaves the size unpriced. Without a connected account: Not priced: connect the AWS account (Integrations > Cloud accounts). .... No new permission: it is inside the stack’s ViewOnlyAccess
Google Cloud Google’s Cloud Billing Catalog spot prices for the machine’s cores and memory. Seylo reads the catalogue with your connected project’s token, which works only where the project has the Cloud Billing API (cloudbilling.googleapis.com) enabled; enabling it grants nothing. Otherwise Seylo reads it with its own key. The first read can take a while: Not priced yet: Seylo is reading Google's Cloud Billing Catalog ...; reload in a minute.
Other clouds Not priced

For a cluster that is not production, this lever switches it off outside the hours you pick:

  1. An admin turns on This cluster is not production in the lever’s detail.
  2. Pick the Days it runs and the hours it Runs from and Until. The default is Monday to Friday, 08:00 to 20:00, in your browser’s time zone.

The detail shows how much of the week the cluster is off.

Until an admin marks the cluster, the lever shows its figure as if non-production and cannot be ticked. The setting is saved on the cluster and recorded in the audit log with who changed it. Only an admin can change it.

Outside the hours, workloads are scaled to zero and the autoscaler removes the empty nodes. One node stays on for the system pods. The saving is that off share of the week, on the nodes the levers above would leave.

Two tables show the nodes you run today and the nodes after the ticked levers. Each row gives the count and machine type, vCPU, GiB, $/h and $ /mo. The totals row adds Instances, vCPU, GiB, App pods and Node agents. Spot rows are marked.

App pods are the same in both tables: packing moves your pods onto fewer or different nodes and never removes one. Node agents are the DaemonSet pods (kube-proxy, network and disk drivers, log and metric collectors) that run one copy on every node, so fewer nodes means fewer copies, and nothing your applications use is lost.

Every price names where it came from:

Three gauges, for CPU, memory and storage:

Figure What it is
Provisioned What the nodes have
Requested What workloads asked for
Used What they actually use

Below them is a chart of the last 7 days, hour by hour; choose CPU, memory or storage.

A large gap between Requested and Used is what Rightsizing recovers. A large gap between Provisioned and Requested is what Fewer, better nodes recovers.

The figures come from the cluster’s own metrics store. Each node, container and volume is counted once, even when two collectors export the same one, for example a second kube-state-metrics, or an older install that still stores OpenCost’s own copy of node capacity. Before 0.4.9 such a cluster could show twice its real capacity. Without a metrics store, Seylo uses the node and pod figures from Kubernetes and the usage its agent collects, and says so and how many pods it covers. Storage used needs the store’s volume statistics; without them it says so.

Apply selected (role releaser) sends each ticked lever for approval:

Lever What is sent What approval does
Rightsizing One resource change per workload: the raises first, then the lowers Applied and read back. Every guardrail is checked again first
Fewer, better nodes The Clear first items and each pool’s new size and count, as tasks Records the decision. Approving it does not resize a node pool
Spot, Schedule Tasks Records the decision. Approving it does not create a spot pool or switch the cluster off

All the tasks go in one approval request. Carry them out in your own tooling or infrastructure as code, or let managed savings carry out the levers it can.

If a lever has nothing left to send, the request is refused with the reason.

Role Can
viewer See the page
releaser Apply selected; Send for approval on a raise
admin Mark a cluster non-production and set its hours; Let Seylo manage savings

Fewer, better nodes, Current vs optimal and the usage from the metrics store need the whole cluster. Someone limited to some namespaces sees what their access allows, and the page says which parts were not read.