Stakeholder Basics

This page shows how to turn concrete cluster facts - node types, load-balancer fees, replica counts, quotas - into short product sentences a stakeholder can act on.

Prerequisites

• kubectl matching your cluster (server on Kubernetes 1.36.2; keep the client within one minor).
• Access to read nodes, resource requests, and Services in the relevant namespaces.
• A cost source: your cloud bill by node pool, or a cost-visibility tool that attributes spend to namespaces and labels.
• Optional: kubectl metrics via kubectl top for live usage alongside requested resources.

Basic Examples

1. Price a node pool in one sentence

Find how many nodes a workload occupies, then quote the node cost, not the abstraction.

kubectl get nodes -l pool=general -o name | wc -l

• Multiply node count by the node type's monthly price from your bill.
• Say "this environment is 6 general nodes, about $X a month," not "we run a general node pool."
• Node type is the biggest cost lever, so always name it.
• Keep the figure as a round number; precision to the cent invites nitpicking.

2. Count load balancers you are paying for

Each Service of type LoadBalancer provisions one cloud load balancer with its own hourly fee.

kubectl get svc -A --field-selector spec.type=LoadBalancer

• The row count is your load-balancer bill in line items.
• Translate to "we pay for N load balancers" before anyone sees the invoice.
• Collapsing several into one Ingress or Gateway is a concrete saving you can propose.
• This is often the fastest cost win to hand a stakeholder.

3. Read requests as pods-per-node

CPU and memory requests, not actual usage, decide how many pods fit on a node.

resources:
  requests:
    cpu: 500m      # a node with 4 usable cores fits ~8 of these
    memory: 512Mi

• Requests are the scheduler's currency; usage is not.
• "Each pod reserves half a core" explains why a node fills at 8 pods.
• Oversized requests waste nodes and money without failing any test.
• Right-sizing requests is a saving that needs no new hardware.

4. Turn replicas into a launch cost

Scaling up for a launch buys real capacity, so price it before you approve it.

kubectl scale deployment/checkout --replicas=8

• Extra replicas need extra node capacity, which the autoscaler will buy.
• "Doubling checkout for the sale adds about one node" is a plannable sentence.
• Redundancy is insurance with a premium, not a free default.
• State the premium so the owner chooses it on purpose.

5. Express headroom as time, not percent

A utilization percentage is data; weeks of runway is a decision.

kubectl describe nodes | grep -A3 "Allocated resources"

• Compare requested CPU and memory against allocatable per node.
• "We are at 85%, roughly three weeks of headroom at current growth" prompts action.
• Headroom framed as time tells the owner when, not just whether, to spend.
• Buying nodes calmly beats scrambling during an incident.

6. Name the blast radius of a single replica

One replica with no disruption budget has a plain business meaning: routine maintenance can cause downtime.

apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
  name: checkout-pdb
spec:
  minAvailable: 1
  selector:
    matchLabels:
      app: checkout

• Without a PDB, a node drain can take a single-replica service fully offline.
• Say "checkout goes dark during maintenance" instead of "no PDB is set."
• A second replica plus a PDB is a small, priceable reliability buy.
• Let the owner accept or reject the downtime knowingly.

7. Attribute spend to a team or feature

Stakeholders act faster when the cost has their name on it.

kubectl get pods -A -l team=payments -o wide

• Label workloads by team and feature so cost tools can split the bill.
• "Payments is 40% of cluster spend this month" starts a real conversation.
• Attribution turns a shared, ignorable bill into an owned one.
• Consistent labels are the prerequisite; enforce them early.

Intermediate Examples

8. Quote unit economics per tenant

When the audience owns pricing, cost per tenant beats total spend.

# spend attributed to a tenant namespace, from your cost tool
# divided by active tenants in that namespace

• Divide attributed namespace spend by active tenants for a per-tenant cost.
• "Each tenant costs $40 to host and pays $30" is a pricing decision, surfaced by the cluster.
• Unit economics let product compare platform cost to customer price directly.
• Flag any tenant whose hosting cost exceeds its revenue.

9. Bound autoscaling so the bill stays plannable

Autoscalers buy nodes automatically, which means they buy spend automatically.

apiVersion: karpenter.sh/v1
kind: NodePool
metadata:
  name: general
spec:
  limits:
    cpu: "200"      # a hard ceiling on how many nodes this pool can add

• A limits ceiling caps worst-case cost during a traffic spike or a runaway loop.
• "Our maximum cluster bill is capped at $Y" reassures finance.
• Unbounded autoscaling is an unbounded invoice; make the ceiling explicit.
• Alert before the cap so scaling out is a decision, not a surprise.

10. Frame a security control as a premium

Default-deny networking costs a little friction and buys containment.

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny
spec:
  podSelector: {}
  policyTypes: [Ingress, Egress]   # deny all until explicitly allowed

• The cost is some engineering time and debugging when a path is blocked.
• The payoff is that one compromised pod cannot roam the namespace freely.
• Say "this limits how far a breach spreads," not "we added a NetworkPolicy."
• Let the owner accept the small delay for the smaller blast radius.

Stack versions: This page was written for Kubernetes 1.36.2, Docker Engine 29.6.1 (BuildKit default), containerd (CRI runtime on nodes), Helm 3, Compose v2, Argo CD (latest - verify at build), and Gateway API (GA - verify controller support at build).