
Article 2 of a series on Kubernetes, Istio, C#/.NET, and Microsoft Entra ID — for architects who have to make this work, and then defend it in an audit.
You've decided to move to Kubernetes. Good. Then you open the documentation and meet forty resource types, three networking layers, and a YAML file that wants to know your pod's DNS policy. This is the moment most people quietly close the tab and go back to the VM that still works.
Here's what the docs won't lead with: you need five boxes to start. Five. The other thirty-five are specializations of problems you don't have yet.

The five boxes
1 .Node. A machine, usually a virtual one. It has CPU and memory, and it runs your containers. A cluster is a pile of nodes. You'll spend remarkably little time thinking about nodes directly, which is the point.
2. Pod. The smallest thing Kubernetes runs. A pod wraps your container — your .NET service — plus a shared network identity. Treat pods as disposable: created, killed, and replaced constantly, on whatever node has room. A pod is cattle, not a pet. The day you ssh into one to "fix" it by hand is the day your cluster stops matching reality.
3. Deployment. The manager. You almost never create pods yourself. You tell a Deployment "keep three copies running, and roll new versions without dropping traffic," and it makes that true. Pod dies? The Deployment replaces it before you've noticed. This is the box that turns "a container" into "a service that stays up."
4. Service. A stable address. Pods come and go and their IPs change every time. A Service is the fixed front door — one name, one virtual IP — that load-balances across whatever pods match its label. Callers don't care that the pods underneath were replaced twice this morning.
5. Control plane. The brain. The API server you talk to with kubectl, the scheduler that decides which node each pod lands on, and etcd, which stores the desired state of everything. You don't run workloads here; it runs the cluster — constantly comparing what you declared against what's actually running, and closing the gap.
That's the model. A Deployment makes Pods, a Service finds them, Pods run on Nodes, and the control plane keeps the whole thing matching what you declared. Ingress, ConfigMaps, StatefulSets, Helm, operators, the mesh we're building toward — everyone is a specialization of those five. Learn the five and the rest stops being intimidating and starts being lookups.
The one honest caveat
If five boxes still sound like a lot to run for three services, you may not need Kubernetes yet. That's not heresy, it's engineering. Azure Container Apps will run your containers with no control plane to babysit; Nomad gives you a scheduler a fraction of the size; some workloads are still fine on a plain VM. Kubernetes is a power tool. If you're hanging one picture, use a screwdriver.
But regulated platforms rarely stay at three services, and the reasons you'll reach for a mesh — enforced identity, provable policy, uniform audit — assume Kubernetes underneath. If that's where you're headed, learn the five boxes now, while the cluster is empty and the mistakes are cheap.
Why this mental model matters for enterprise institutions
Here's the part that turns a DevOps concept into a compliance asset: Kubernetes is declarative, and declarative means auditable.
The control plane holds the desired state of everything running. kubectl get doesn't show a hopeful guess — it shows data: what's deployed, which version, how many replicas. When a regulator asks "what exactly is running in production, and how do you know," the answer is a query, not a screenshot and a prayer. That's a genuinely different posture from a fleet of hand-tended VMs where the real configuration lives in someone's memory.
The failure mode is just as specific. A team that never internalized "pods are cattle" starts treating them as pets — SSHing in, patching by hand, tweaking live. Now the cluster's actual state has drifted from what git says is deployed, and nobody can prove what's running. In a bank or an NBFC that's not untidiness — it's an audit finding. The five-box model is what keeps declared and actual the same thing, which is the foundation the later evidence and drift-detection work stands on.
And nodes matter more than they look. The scheduler decides where pods run, so node pools are where data-residency lives. RBI wants payment data in India; SAMA wants it in-Kingdom. You express that as placement — the same box, doing regulatory work.
The code, and the one thing beginners get wrong
Your app barely changes. Here's a .NET 8 minimal API — the running example for the rest of the series:

And the two boxes that turn it into a running service — a Deployment and a Service:

Look at the labels. The Service's selector (app: accounts-api) has to match the labels the Deployment stamps on its pods. That string match is the wiring between Box 4 and Box 2. Get it wrong — a typo, a plural, a stray environment suffix — and the Service points at nothing, your pods are healthy, and every request 503s while everything looks fine. It's the single most common first-week Kubernetes outage, and now you know exactly where to look.
Security · Audit · Integration — the through-line
The alternatives, honestly
Azure Container Apps. Serverless containers, scale-to-zero, no control plane to operate. Pick it when you have a handful of services and don't want to run Kubernetes. You give up fine-grained networking and policy — which, for the regulated mesh story, you eventually need back.
HashiCorp Nomad. A scheduler a fraction of Kubernetes' surface area. Pick it when Kubernetes' complexity is more than your team can carry and you don't need the ecosystem.
Plain VMs. Still valid for some workloads. Orchestration you don't need is just latency and risk you added on purpose.
The question is never "is Kubernetes good" — it's "do my problems look like the problems Kubernetes solves." For a single service, probably not. For a regulated platform heading toward zero-trust identity and provable audit, yes — and the five boxes are where that road starts.
From here to the standard
The five boxes scale all the way up. A regulated production cluster is these same pieces plus isolation (namespaces, network policy), plus the mesh we're building toward. Same model, more rigor. Nobody graduates past Node-Pod-Deployment-Service-control-plane; they just wrap more guarantees around them.
Next up: Your first .NET 8 service on Kubernetes — we take the code above and actually ship it. Dockerfile, build, push, deploy, and watch a rollout happen in real time.
Follow along if you're building regulated workloads on Kubernetes. Twice a week.
Key skills & topics in this article
Also on LinkedIn.