Ask a platform engineer to "explain how a Kubernetes pod gets scheduled" and you will get a clean, confident answer from someone who has never once fixed a pod stuck in Pending. The words are memorizable. The job is not.
Platform work is diagnosis under uncertainty. A deploy is failing, the on-call is paging, and the person has to read the cluster's actual state and act. That is the thing you want to measure, and a verbal walkthrough measures none of it.
The alternative is simple: give the candidate a real cluster that is already broken, and watch them fix it.
Why the verbal Kubernetes interview fails
A whiteboard Kubernetes question rewards vocabulary. It tells you the candidate has read about controllers, services, and ingress. It does not tell you whether they can find why a rollout is wedged at 3 replicas of 5.
The gap shows up fast in real work. We have watched engineers who could recite the reconciliation loop freeze the moment kubectl get events scrolled past. And we have watched quieter candidates who fumbled the theory question calmly walk a CrashLoopBackOff back to a missing config key in under ten minutes.
Recall and operation are different skills. Only one of them is the job.
Give them a cluster that is already broken
The cleanest platform interview is a running cluster with a real, reproducible fault, plus kubectl access and a short brief: "the checkout service should be serving traffic and it is not. Find out why and fix it."
Good broken scenarios share the traits of any good debugging task (we cover the general version in how to assess debugging skill):
- The fault is real and reproducible, not a trivia trap.
- The blast radius is bounded to a namespace or two, so the session is about reasoning, not scale.
- There is one correct restored behavior, so success is unambiguous.
- Finding it takes investigation; fixing it is small once found.
Scenarios that discriminate well:
- A pod stuck in
Pending because of an unschedulable resource request or a missing node selector. Tests whether they read kubectl describe before guessing.
- A
CrashLoopBackOff driven by a bad env var or a missing secret. Tests whether they read logs and reason about the container lifecycle.
- A service with no endpoints because a label selector does not match the pod labels. Tests whether they understand how services actually find pods, not just what a service is.
- A rollout wedged mid-deploy by a failing readiness probe. Tests whether they can tell "the app is broken" from "the probe is wrong."
- A misconfigured resource limit that gets pods OOMKilled under load. Tests whether they connect a symptom to a cause across two layers.
Each one has a clean answer and a messy path to it. The path is what you are buying.
What to watch for
The fix matters less than how they get there. Strong platform engineers show a recognizable pattern:
- They look before they touch.
kubectl get, describe, events, logs, in that rough order. They build a picture of current state before changing anything.
- They read events and conditions. Kubernetes usually tells you what is wrong in
describe output. Weak candidates scroll past it; strong ones stop and read the Events block.
- They form a hypothesis out loud. "The service has no endpoints, so either the pods are not ready or the selector is wrong, let me check the labels." That sentence is worth more than a correct answer with no reasoning.
- They change one thing at a time. Panic looks like editing three manifests at once and re-applying with no idea which change mattered.
- They know the blast radius. Before they
delete or apply, do they consider what else it touches? That instinct is the difference between a safe operator and an incident.
Watch for the anti-patterns too: reaching for kubectl delete pod as a first move (restarting to make a symptom disappear without understanding it), editing live resources with no record of what changed, or narrating the textbook while ignoring what the cluster is actually reporting.
Scoring it without hand-waving
Turn the behaviors above into a short rubric so two interviewers reach the same verdict (more on that in how to write a technical interview rubric). Score the observable process, not just the outcome:
- Did they reproduce and confirm the failure before acting? (yes / no)
- Did they use the right read commands to localize it? (fluent / slow / never got there)
- Did they explain a hypothesis before the fix? (clear / vague / none)
- Was the fix minimal and correct, or a broad guess that happened to work?
- Did they consider blast radius before a destructive command?
A candidate can fail to fully fix the cluster and still score well if the reasoning is sound and time simply ran out. A candidate who fixes it by luck, with no explanation and a trail of unrelated edits, is not the operator you want on call.
Why we run this in a real environment
You cannot fake a Kubernetes cluster on a shared document. The interesting signal is the sequence of commands and how the cluster responded, and that only exists if there is a real cluster.
EasyEnv gives the candidate a live environment (we call it a workspace) with a genuinely broken cluster inside it, and records the session. You see the terminal, every command, and the order they ran, so a fuzzy "they seemed to know their way around" becomes a concrete record you can review with the rest of the panel. For a role where the cost of a wrong hire shows up at 2am, that record is worth more than any answer to "explain a pod."
The takeaway
Reciting Kubernetes concepts is a baseline. Restoring a broken cluster under mild pressure is the job. Hand the candidate something broken, watch how they narrow it down, and score the path, not just the fix.
Interview for the on-call, not the exam.