Glossary
Definitions of terms used throughout CostPilot documentation, the dashboard, and API.
Allocation
The process of attributing a share of infrastructure cost to a specific workload, team, namespace, or label. CostPilot allocates costs using resource requests as the primary basis, falling back to actual usage for BestEffort pods. Allocation is a model — it approximates how costs map to workloads rather than reading directly from a cloud bill.
Alerts
A paid plan feature that notifies you when spending crosses a defined threshold. CostPilot supports three alert types: Absolute threshold (fixed spend limit), Percentage change (week-over-week or day-over-day spike detection), and Daily budget (projected daily rate). Alerts are distinct from Notifications, which are operational system events.
Analysers
The individual cost analysis engines that power CostPilot Insights. Free plan accounts run 4 analysers; paid plan accounts run 11. All analysers execute in parallel, taking approximately 200ms total regardless of how many run. See Plans & Entitlements for the full list.
BestEffort
A Kubernetes QoS class assigned to pods that have no resource requests or limits set on any container. BestEffort pods are the first to be evicted when a node is under resource pressure. CostPilot allocates cost to BestEffort pods based on their actual observed usage rather than requests (which do not exist). See QoS Classes & Cost Impact.
Burstable
A Kubernetes QoS class assigned to pods that have at least one resource request set, but do not meet the Guaranteed criteria (e.g. requests ≠ limits, or only some resources have requests). CostPilot allocates cost based on the requests that are set. Burstable pods are evicted after BestEffort but before Guaranteed.
Chargeback
A financial model where infrastructure costs are billed back to the teams or business units that incurred them. In CostPilot, chargeback is implemented by mapping Kubernetes label keys to the Team (or Cost Centre) semantic role, then exporting cost-by-label reports. Compare with Showback.
Cluster API Key
A secret token that authenticates the CostPilot agent with the ingest backend. Each cluster has its own unique API key, scoped exclusively to that cluster. Generated in Nodes → Clusters and stored as a Kubernetes Secret in the costpilot namespace.
Cost Centre
A semantic role that can be assigned to a label mapping in CostPilot. When a Kubernetes label key is mapped to the Cost Centre role (e.g. cost-centre: CC-1042), CostPilot uses that label value as the cost centre identifier in attribution reports. Supports finance team chargeback workflows.
CPU Request
The amount of CPU a pod container declares it needs, specified in millicores (e.g. 500m = 0.5 CPU). Kubernetes uses this value for scheduling decisions. CostPilot uses CPU requests as the primary basis for cost allocation (except for BestEffort pods). Setting accurate CPU requests is the single most impactful action for improving cost accuracy.
DaemonSet
A Kubernetes resource that ensures one pod runs on every node (or every node matching a selector). DaemonSet pods are allocated a proportional share of node cost in CostPilot — their cost is spread across all nodes they run on, rather than attributed to a single workload. Useful for monitoring, logging, and security agents.
Dimension
A grouping axis in Cost Explorer. Available dimensions include Cluster, Namespace, Node, Workload, Pricing type, and (on Pro/Max plans) Label-based dimensions such as Team, Environment, Cost Centre, Application, Service, and Custom. You can group by one dimension at a time and filter by one or more dimensions simultaneously.
Efficiency Score
A weighted ratio of actual resource usage to resource requests, expressed as a percentage and graded A–F. Efficiency is calculated separately for CPU and memory, then combined:
CPU efficiency = actual CPU usage ÷ CPU requests
Memory efficiency = actual memory usage ÷ memory requests
Overall = (CPU efficiency + memory efficiency) ÷ 2Grades: A = 90–100%, B = 75–89%, C = 60–74%, D = 45–59%, E = 30–44%, F = 0–29%.
Guaranteed
A Kubernetes QoS class assigned to pods where every container has CPU and memory requests and limits set, and requests equal limits. Guaranteed pods are the last to be evicted. CostPilot allocates cost based on requests (which equal limits). Appropriate for latency-critical, production workloads. See QoS Classes & Cost Impact.
Idle Cost
The portion of infrastructure spend that produces no useful work. CostPilot tracks two types:
- Overprovisioned idle: pod requests minus actual pod usage
- Unallocated idle: node capacity minus total pod requests (capacity no pod has claimed)
Idle cost is visible on the Dashboard as a percentage of total spend and broken down by type.
Ingester
The CostPilot backend service that receives metric batches from the agent (via Cloudflare Workers) and writes them to a Valkey stream for processing. The ingester is an internal CostPilot service — it is not a component you deploy.
Insight
An automatically generated cost optimisation recommendation produced by CostPilot’s analysers. Insights are triggered when 5,000 metrics have been collected from a cluster. Each insight has a severity (critical, warning, info), a title, a description, and an estimated saving. Insights can be acknowledged, actioned, or dismissed.
Label Mapping
A configuration in CostPilot (Settings → Labels) that maps a Kubernetes label key to a semantic role. For example, mapping the label key team to the Team role tells CostPilot to use that label’s values for team-level cost attribution. Six roles are available: Team/Ownership, Environment, Cost Center, Application, Service, and Custom. Multiple Custom mappings can be added alongside the standard roles.
Memory Request
The amount of memory a pod container declares it needs, specified in bytes with SI suffixes (e.g. 256Mi, 1Gi). Like CPU requests, memory requests inform Kubernetes scheduling and CostPilot cost allocation. Setting accurate memory requests reduces the risk of OOMKill events and improves allocation accuracy.
Namespace
A Kubernetes mechanism for grouping resources within a cluster. CostPilot uses namespaces as a cost grouping dimension in Cost Explorer. Namespace-level cost attribution is available on both free and paid plans. For team-level attribution, label mappings are more precise than namespace grouping (unless each team has its own namespace).
Node Pool
A group of Kubernetes nodes sharing the same instance type, region, and configuration. In CostPilot, node pool composition (instance types, spot vs on-demand) determines the per-CPU and per-GB-memory pricing rate used for cost allocation. Reducing node pool size is the primary lever for reducing unallocated idle cost.
Notifications
Real-time operational events delivered to the CostPilot dashboard via Server-Sent Events (SSE). Examples: “Cluster connected”, “Insights generated”, “Agent offline”. Notifications are distinct from Alerts — they are informational and always free. Alerts are threshold-triggered, paid, and delivered to external channels.
Operator (CostPilot)
The Kubernetes Operator deployed by the CostPilot Helm chart. It manages the lifecycle of the agent ReplicaSet — ensuring the correct number of agent replicas are running and restarting failed pods. The Operator runs as a single Deployment with leader election.
Overprovisioned
A workload where resource requests significantly exceed actual usage. An overprovisioned pod pays for capacity it does not use, contributing to idle cost. The efficiency score reflects the degree of overprovisioning — a grade F workload is severely overprovisioned. See Right-size Workloads.
PersistentVolume
A Kubernetes storage resource that persists beyond the lifetime of a pod. CostPilot includes PersistentVolume costs in workload attribution, estimated from storage class pricing. PV costs appear in Cost Explorer alongside compute costs.
Pod
The smallest deployable unit in Kubernetes — one or more containers that share network and storage. CostPilot collects metrics at the pod level and uses pod labels, QoS class, and resource configuration to determine cost allocation. Pod-level data is aggregated into workload and namespace views in Cost Explorer.
QoS Class
Kubernetes assigns one of three Quality of Service classes to every pod: Guaranteed, Burstable, or BestEffort. The class determines eviction priority and influences which allocation method CostPilot uses. See QoS Classes & Cost Impact.
Showback
A cost visibility model where infrastructure costs are reported back to teams for awareness, but not actually billed. Teams can see what their workloads cost without receiving an invoice. Compare with Chargeback, where costs are billed back. CostPilot supports both models — the label attribution and export features work identically for either use case.
Spot Instance
A cloud provider instance sold at a heavily discounted price (60–90% below on-demand) in exchange for the possibility of interruption with short notice. AWS calls these Spot Instances; GCP calls them Preemptible or Spot VMs; Azure calls them Spot Virtual Machines. CostPilot detects spot nodes from provider labels and reflects actual spot pricing in cost breakdowns. See Spot & Preemptible Instances.
Tenant
A CostPilot account. All users, clusters, and cost data within an account belong to a single tenant. Tenant data is strictly isolated from other tenants. Each tenant has a unique identifier used throughout the platform.
Unallocated
Node capacity that no pod has claimed through resource requests. Unallocated capacity is a form of idle cost — the node is running and incurring cost, but no workload has reserved that capacity. Resolved by enabling Cluster Autoscaler or manually reducing node pool size.
Workload
In CostPilot, a workload is a named group of pods managed by the same controller (Deployment, StatefulSet, DaemonSet, Job, or CronJob). The Cost Explorer Workload dimension shows cost aggregated at the controller level, making it easier to evaluate the total cost of a service across all its replicas.