Top Kubernetes Interview Questions & Answers (2026)
17 questions Kubernetes Administrator interviewers actually ask, with the strong answer, the weak one, and the follow-up that comes next.
- Kubernetes AdminRole
- $100K-$160KTypical US pay
- 4-5 roundsInterview loop
- Often preferredCert in hiring
- UsuallyHands-on test

Table of Contents
Kubernetes administrator and platform engineer roles sit on infrastructure, SRE and platform teams at SaaS companies, banks, retailers and consultancies running their own clusters or managed ones like EKS, AKS and GKE. The job is keeping clusters healthy, upgraded and secure, and giving developers a paved road to ship on. Titles vary a lot: the same work is advertised as platform engineer, DevOps engineer or cloud engineer.
Interviews in 2026 are hands-on. Expect a live troubleshooting session in a real cluster or a shared terminal, a design conversation about multi-tenancy, networking and upgrades, and questions about how you behave during an outage. The CKA helps because it is itself a performance-based exam run against a live cluster, so recruiters read it as proof you can work at the command line. It will not answer the design and judgement questions for you.
What the Kubernetes Administrator interview loop looks like
Most Kubernetes Administrator / Platform Engineer hiring runs 5 rounds. Each one is testing something different, so prepare for each separately.
The 17 questions, with answers
Each card shows the question as it is usually asked, what the interviewer is really checking, a strong answer, the weak answer they hear most often, and the follow-up that comes next. Say the strong answers in your own words — a memorised script sounds memorised.
- Basic · 4
- Core · 5
- Advanced · 3
- Scenario · 3
- Behavioural · 2
Walk me through the control plane components and what each one actually does.
What they are testing: Whether you understand how the pieces talk to each other, not just their names
The API server is the front door. kubectl, controllers and every kubelet talk to it, and it is the only component that talks to etcd. etcd is the consistent key-value store that holds all cluster state, which is why it is the thing I back up. The scheduler watches for pods with no node assigned and picks a node based on requests, affinity, taints and spreading. The controller manager runs the reconcile loops, like the Deployment, ReplicaSet, node and service account controllers. On every node the kubelet takes pod specs and drives the container runtime, usually containerd, and kube-proxy programs Service rules unless the CNI replaces it. On kubeadm clusters the control plane runs as static pods from /etc/kubernetes/manifests.
When would you pick a Deployment, a StatefulSet or a DaemonSet?
What they are testing: Whether you know what each controller guarantees, not just the textbook use case
A Deployment is for stateless, interchangeable replicas. It manages ReplicaSets, so I get rolling updates and rollbacks for free, and any pod can replace any other. A StatefulSet is for workloads that need identity: each pod gets a stable name like db-0 and db-1, a stable DNS entry through a headless Service, ordered startup and its own PersistentVolumeClaim from volumeClaimTemplates. That is what databases, Kafka or ZooKeeper need. A DaemonSet runs one pod per matching node, so it is the right fit for log shippers, node exporters, CNI agents or CSI node plugins. If the work runs to completion instead of forever, I would use a Job or CronJob instead of any of these.
Explain the Service types and how a request to a ClusterIP actually reaches a pod.
What they are testing: Whether you can connect selectors, EndpointSlices, kube-proxy and DNS into one path
A Service selects pods by label, and the control plane keeps EndpointSlices listing the IPs of the matching pods that are Ready. A ClusterIP Service gets a virtual IP that only exists inside the cluster. kube-proxy on every node, in iptables or nftables mode, programs rules so traffic to that IP and port is translated to one of the pod IPs, or an eBPF-based CNI like Cilium does the same job. Pods usually find it by name through CoreDNS, as name.namespace.svc.cluster.local. NodePort opens the same port on every node, LoadBalancer asks the cloud for an external load balancer on top of that, ExternalName just returns a CNAME, and a headless Service with clusterIP set to None returns pod IPs directly.
What is the relationship between a PersistentVolume, a PersistentVolumeClaim and a StorageClass?
What they are testing: Whether you understand dynamic provisioning and reclaim behaviour, which is where data gets lost
The PersistentVolumeClaim is the app's request: a size, an access mode such as ReadWriteOnce or ReadWriteMany, and a storage class. The PersistentVolume is the actual piece of storage, and a claim binds to exactly one volume. The StorageClass names a CSI provisioner plus parameters like disk type, so when a claim references it the driver creates the disk and the PV automatically. Two settings matter a lot in practice. The reclaim policy is Delete by default for dynamically provisioned volumes, so deleting the claim deletes the disk unless you use Retain. And volumeBindingMode WaitForFirstConsumer delays provisioning until the pod is scheduled, so the disk is created in the same zone as the node.
A pod is stuck in CrashLoopBackOff. Talk me through exactly how you debug it.
What they are testing: A structured method using events, exit codes and previous logs instead of guessing
CrashLoopBackOff means the container keeps starting and exiting, and the kubelet is backing off restarts, up to five minutes between attempts. First I run kubectl describe pod and read the events and the last state: the exit code and reason tell me a lot. Exit 137 with reason OOMKilled means the memory limit is too low or the app leaks. Exit 1 usually means the app itself failed, so I run kubectl logs with the previous flag to see the crashed container's output, not the fresh one. I also check for a liveness probe killing a slow starter, a missing ConfigMap key or Secret, or a wrong command or args. If it dies too fast to inspect, I use kubectl debug to start a copy with a different command.
How does RBAC work, and how would you let a CI pipeline deploy to one namespace and nothing else?
What they are testing: Least privilege in practice, and whether you verify permissions instead of assuming
RBAC is additive allow-only. A Role or ClusterRole lists verbs on resources, and a RoleBinding or ClusterRoleBinding attaches it to users, groups or service accounts. A RoleBinding can reference a ClusterRole, which scopes that reusable role to one namespace. For CI I would create a service account in the target namespace, a Role allowing get, list, watch, create, update and patch on Deployments, Services and ConfigMaps there, and a RoleBinding. I would not hand out the built-in edit role without thinking, because it includes Secrets. Then I verify with kubectl auth can-i, using the as flag with the service account name, both in that namespace and in another one where it should be refused. I prefer short-lived tokens or workload identity over long-lived token Secrets.
How do NetworkPolicies work, and what changes when you apply a default-deny policy?
What they are testing: Whether you know policies are additive allow-lists that need a capable CNI, and the DNS gotcha
By default every pod accepts traffic from anywhere. A NetworkPolicy selects pods in its namespace, and once any policy selects a pod for ingress, only the traffic some policy explicitly allows gets in. The same applies separately to egress. Policies only add allows, there is no deny rule, and reply traffic for an allowed connection is permitted. A default deny is a policy with an empty podSelector and policyTypes Ingress, Egress, or both. Two practical points. Enforcement depends on the CNI, so Calico or Cilium will enforce it while a plain flannel setup silently ignores it. And if you deny egress, you must allow UDP and TCP 53 to CoreDNS in kube-system, or every name lookup breaks and it looks like an app bug.
How do you back up and restore etcd on a kubeadm cluster?
What they are testing: Whether you have done it with the right certs and tools, and understand what a restore means
On kubeadm, etcd runs as a static pod and its certificates live under /etc/kubernetes/pki/etcd. I take a snapshot with etcdctl snapshot save, passing the endpoint https://127.0.0.1:2379 and the cacert, cert and key flags for those files, then check it with etcdutl snapshot status. The snapshot contains every Secret, so it goes off the node to encrypted storage, on a schedule. To restore, I stop the API server and etcd by moving their manifests out of the manifests folder, run etcdutl snapshot restore into a new data directory, point the etcd manifest's data volume at that directory, and move the manifests back. Then I confirm nodes and workloads come back. And I test restores on a scratch cluster, because an untested backup is a hope.
What is the difference between liveness, readiness and startup probes, and how do teams get them wrong?
What they are testing: Whether you can prevent probes from turning a small blip into a cascading outage
A readiness probe decides whether the pod receives traffic. If it fails, the pod is removed from the Service endpoints but is not restarted. A liveness probe decides whether the container is stuck; if it fails enough times, the kubelet restarts the container. A startup probe holds off the other two until a slow app has finished booting, so a JVM that takes ninety seconds is not killed at thirty. The classic mistake is a liveness probe that checks the database. The database blips, every pod fails liveness at once, everything restarts together, and a small problem becomes an outage. I keep liveness cheap and local to the process, and use readiness for dependency checks.
Walk me through upgrading a kubeadm cluster by one minor version without taking workloads down.
What they are testing: Correct order, version skew rules, and protecting workloads during node drains
I read the release notes for removed APIs, check manifests and Helm charts against them, and take an etcd snapshot. Upgrades go one minor version at a time, control plane first. The pkgs.k8s.io repositories are per minor version, so I point the package repo at the new minor, upgrade kubeadm, run kubeadm upgrade plan, then kubeadm upgrade apply with the target version on the first control plane node and kubeadm upgrade node on the others. Then, node by node, I drain with ignore-daemonsets, upgrade kubelet and kubectl, run systemctl daemon-reload, restart kubelet and uncordon. Workloads survive because they run multiple replicas with PodDisruptionBudgets, so drains evict gradually. The kubelet can lag the API server by up to three minors but must never be newer.
Ingress NGINX was retired in March 2026. How would you move a cluster from it to Gateway API?
What they are testing: Awareness of the retirement and a careful, side-by-side migration plan
The Kubernetes project stopped maintaining Ingress NGINX in March 2026, so there are no more security fixes, even though existing installs keep running. The Ingress API itself is not removed, just frozen, so the long-term direction is Gateway API. Its model splits ownership: a GatewayClass from the infrastructure provider, a Gateway with listeners owned by the platform team, and HTTPRoutes that app teams attach. My plan is to inventory every Ingress, especially the nginx annotations for rewrites, auth and rate limits, because those do not carry over automatically. I pick a conformant implementation, convert with ingress2gateway as a starting point, run the new Gateway in parallel on its own load balancer, test each host, then shift DNS gradually and remove the old controller.
How does the scheduler decide where a pod lands, and what tools do you use to influence it?
What they are testing: Requests versus usage, taints versus affinity, and spreading for resilience
It filters, then scores. Filtering removes nodes that cannot run the pod: not enough allocatable resources for its requests, which is about requests, not live usage, a nodeSelector or required affinity that does not match, a taint it does not tolerate, or a volume in another zone. Scoring then ranks what is left on things like balance, preferred affinity and image locality. To influence it, I set accurate requests first, because everything depends on them. I use node affinity for hardware needs, taints plus tolerations to keep general pods off GPU nodes, and topologySpreadConstraints or pod anti-affinity to spread replicas across zones and nodes. A toleration alone only permits a node, it does not attract the pod, so dedicated pools need affinity too. PriorityClasses decide who gets preempted.
A worker node shows NotReady and pods on it are being evicted. What do you check, in order?
What they are testing: Node-level troubleshooting with kubelet, runtime, disk and certificates, done calmly
First kubectl describe node to read the conditions and last heartbeat: DiskPressure, MemoryPressure or PIDPressure point one way, a stale heartbeat means the kubelet stopped reporting. I cordon it so nothing new lands there. Then on the node I run systemctl status kubelet and journalctl -u kubelet to see why it is failing, and check the runtime with systemctl status containerd and crictl ps. Common causes are a full disk under /var/lib, an expired kubelet client certificate, a crashed CNI agent pod, or the node being overloaded. Once the node is unreachable or not ready, the control plane taints it and pods are evicted after their toleration, five minutes by default. After the fix I uncordon and confirm workloads rebalance.
Users say a Service times out, but kubectl shows every pod Running. How do you find the break?
What they are testing: Methodical layer-by-layer checks from selector to endpoints to port to policy
I work from the pods outward. First I list the EndpointSlices for the Service. If there are none, either the selector does not match the pod labels, often a typo or a version label, or the pods are Running but not Ready because readiness is failing. If endpoints exist, I check that targetPort matches the port the app listens on, and that the app binds to 0.0.0.0, not 127.0.0.1. Then I start a debug pod and test in steps: curl the pod IP directly, then the ClusterIP, then the DNS name. Whichever step fails tells me the layer. After that I check NetworkPolicies selecting those pods, and the kube-proxy or CNI logs on the node.
A new StatefulSet will not start because its PVC is stuck in Pending. Walk me through it.
What they are testing: Storage troubleshooting from StorageClass to CSI driver to topology
kubectl describe pvc gives me the events, which usually name the problem. Typical causes: no storageClassName and no default StorageClass, or a typo in the class name. The CSI provisioner pods may be down or lack cloud permissions to create disks, so I check their logs. If the class uses WaitForFirstConsumer, Pending is normal until the pod is scheduled, so then the real question is why the pod is not scheduling, often because no node in the volume's zone has capacity. Another one is asking for ReadWriteMany from a block storage driver that only supports ReadWriteOnce. For static provisioning, the PV must match the size, access mode and class or it will never bind.
Tell me about a production incident you handled on a cluster. What happened and what did you change afterwards?
What they are testing: Calm incident handling, clear communication and real follow-through after recovery
This is a template; fill it with your own incident. Situation: one sentence on the system and the impact, for example checkout errors after a node pool upgrade. Task: your role, such as incident commander or the engineer on call. Action: how you stabilised first, maybe rolling back or cordoning nodes, how you kept stakeholders updated on a fixed cadence, and how you found the root cause with evidence rather than guesses. Result: time to recover and customer impact in numbers you can stand behind. Then the part interviewers care about most: the follow-up you drove, like a PodDisruptionBudget standard, an upgrade runbook, or an alert that now catches it earlier. Keep the tone blameless.
Tell me about a time a development team wanted something from the platform that you thought was unsafe.
What they are testing: Whether you can protect the platform without becoming a blocker
This is a template for your own story. Situation: a team asked for something risky, for example cluster-admin for their pipeline, privileged pods, or skipping resource limits to hit a deadline. Task: keep them shipping while protecting the shared cluster. Action: show that you found out what they actually needed, explained the risk in their terms, such as a bad deploy affecting every other team, and offered a safe path, like a namespaced role, a pre-approved exception with an expiry, or a template that does it properly. Result: they shipped on time and the safer pattern became the default for others. Interviewers want to hear that you said yes to the goal and no only to the unsafe method.
Get the theory airtight before the interview
Interviewers build follow-ups on the fundamentals. The CKA app has exam-style CKA questions with an explanation for every option, so the basics stay automatic when the questions get harder.
App StoreGoogle PlayFree CKA practice testThe practical task
Expect some version of this. Companies vary the details, not the shape.
You get SSH and kubectl access to a small kubeadm cluster. The web Deployment in the shop namespace is not reachable through its Service, and one worker node is NotReady. Restore both and explain each root cause. Then create a service account that can only manage Deployments in shop, and add a NetworkPolicy so only pods labelled app=frontend can reach the database pods on port 5432.
- Survey first: kubectl get nodes and pods across namespaces, then read events before touching anything
- On the NotReady node, check kubelet and containerd status and journalctl -u kubelet to find the real cause
- For the Service, list EndpointSlices, compare selector to pod labels and targetPort to the container port
- Fix one thing at a time and verify each with a debug pod and curl before moving on
- Create the Role and RoleBinding, then prove scope with kubectl auth can-i inside and outside shop
- Apply the NetworkPolicy and test that frontend reaches 5432 while another pod is refused
Hire vs no-hire:Hires read events and state before changing things, fix root causes instead of restarting, verify every change, and prove the RBAC and policy work with a negative test, not just a positive one.
Questions to ask them
"Do you have any questions for us?" is still being scored. Four that land well for a Kubernetes Administrator role:
Mistakes that sink candidates
What the CKA does and does not prove
What the CKA gets you
The CKA is one of the few infrastructure certs many hiring managers respect, because it is a performance-based exam solved in a live cluster rather than multiple choice. It often appears as preferred in Kubernetes, platform and DevOps postings, and it helps career changers and people from Windows or VM backgrounds get past recruiter filters. It is valid for two years, so keep it current.
What it does not prove
The exam does not test running clusters at scale over months: upgrade planning across many clusters, multi-tenancy design, cost control, observability stacks, GitOps tooling, or incident leadership. It also uses kubeadm-style clusters, while many jobs run managed EKS, AKS or GKE with cloud IAM and networking on top. Interviews probe these areas hard through design rounds and incident stories.
Pay:Range anchored on the BLS May 2025 median for network and computer systems administrators ($99,130) at the low end and Indeed's October 2026 US average for platform engineers ($158,258) at the high end. Location, cloud depth, on-call and production scale move it most.
Still sitting the CKA?
Pass it first time and walk into the interview with the credential on your CV. The CKA app has exam-style CKA questions with an explanation for every option.
App StoreGoogle PlayFree CKA practice testFAQ
Is the CKA enough to get a Kubernetes job with no other experience?
Usually not on its own. It proves you can work in a cluster under time pressure, which is valuable, but most roles also want Linux, networking, a cloud provider and some scripting or infrastructure as code. Pair the cert with a public project, such as a GitOps-managed cluster with monitoring and a documented upgrade, and you have something real to talk through in interviews.
Will interviews be live in a terminal?
For most platform roles, yes. Expect at least one round where you share a terminal or get a lab cluster and fix something while talking. Some companies use a take-home instead. Practise narrating your thinking while you type, because silent fixing makes it hard for interviewers to give you credit for good reasoning.
Should I study CKAD or CKS before interviewing?
Not before your first interviews. CKA matches the administrator role best. CKS is worth it later if you are aiming for security-heavy platform work, and CKAD suits people who build apps on Kubernetes. Interviewers care more about depth in troubleshooting and design than about collecting all three.
How much should I know about managed services like EKS, AKS and GKE?
Enough to explain what the provider runs for you and what you still own: node pools, upgrades, networking, IAM integration and add-ons. Many postings are for managed clusters, so be ready to compare them to kubeadm and talk about how cloud identity maps to Kubernetes RBAC.
What projects impress Kubernetes interviewers?
Projects that show operations, not just deployment. Good examples: a cluster you upgraded across a minor version with notes, an etcd backup and tested restore, a migration from Ingress to Gateway API, or a NetworkPolicy and RBAC baseline with tests. Write up what broke and how you fixed it.
Sources
Figures on this page come from CNCF and the other primary sources below:
- Certified Kubernetes Administrator (CKA) - The Linux Foundation
- Network and Computer Systems Administrators - BLS Occupational Outlook Handbook
- Platform Engineer salaries in the United States - Indeed
- Operating etcd clusters for Kubernetes - kubernetes.io
- Version Skew Policy - kubernetes.io
- Ingress NGINX Retirement: What You Need to Know - Kubernetes Blog
- Gateway API - kubernetes.io
Checked November 4, 2026. Fees, outlines and eligibility rules change — confirm with CNCF before you book.
