Skip to content

Top 35 Kubernetes Interview Questions and Answers [2026]

October 12, 2026 19 min read
Kubernetes interview guide by Second Talent
TL;DR: Kubernetes interviews in 2026 test the control plane and reconciliation, probes and resource requests, scheduling, Services and Gateway API, storage, RBAC and troubleshooting. Candidates should know that Kubernetes 1.37 is current, that in-place Pod resize went GA in 1.35, and that Ingress NGINX was retired in March 2026.

The Kubernetes project retired Ingress NGINX on March 24, 2026. There have been no releases or security fixes since, so the controller that fronted a large share of the world's clusters now points everyone at Gateway API.

That is the kind of change a 2026 interview checks for, on top of the fundamentals: how controllers reconcile state, why a Pod is Pending, and what a resource limit does to a Java service at 3 a.m.

Key takeaways
  1. 1The project maintains the three newest minors, 1.35, 1.36 and 1.37; the latest patch is 1.37.1 (September 23, 2026), and 1.34 reaches end of life on October 27, 2026.
  2. 2Since 1.35 the kubelet refuses to start on cgroup v1 nodes by default, and 1.35 was the last release to support containerd 1.x.
  3. 3kube-proxy's ipvs mode is deprecated; nftables, stable since 1.33, is the recommended replacement on Linux.
  4. 4Helm 4 shipped on November 12, 2025, with server-side apply support and a WebAssembly plugin system.

Cluster Architecture

1. What are the control plane components, and what does each do?

  • kube-apiserver: the only component that talks to etcd. It authenticates, authorizes and runs admission on every request, and serves watches to everything else.
  • etcd: the consistent key-value store holding all cluster state.
  • kube-scheduler: assigns unscheduled Pods to nodes by filtering nodes that fit and scoring the rest.
  • kube-controller-manager: runs the built-in controllers: Deployment, ReplicaSet, Job, node lifecycle, EndpointSlice and more.
  • cloud-controller-manager: the cloud-specific controllers, such as load balancers for Services and node lifecycle on the provider.

On each node, the kubelet runs Pods through the container runtime (containerd or CRI-O) and reports status, and kube-proxy or a CNI replacement programs Service routing.

A candidate should say that no component other than the API server writes to etcd; everything else watches the API.

2. Why does etcd need an odd number of members, and how do you protect it?

etcd uses the Raft consensus protocol, and a write commits only when a majority of members agree.

Three members tolerate one failure and five tolerate two; a fourth member adds no tolerance over three and adds one more machine that can fail. Losing quorum makes the cluster read-only at best.

Protection is regular snapshots (etcdctl snapshot save) stored off the cluster and a tested restore, encryption of Secrets at rest through the API server's encryption configuration, and fast disks, because etcd is sensitive to fsync latency.

On managed clusters (EKS, GKE, AKS) the provider runs etcd, but the question still tests whether the candidate knows what is being managed.

3. What is the reconciliation loop?

Every controller compares the desired state in an object's spec with the actual state it observes, and acts to close the gap, then records what it saw in status.

It repeats on every change event and on a periodic resync, so the system heals from missed events and manual interference.

Cycle of a Kubernetes controller: watch the API for changes, compare the desired spec with the observed state, act to close the gap by creating, updating or deleting objects, then write what it saw to status and wait for the next event.

This is why Kubernetes is declarative: you change the spec, not run commands. It is also why controllers must be idempotent, because the same object can be reconciled many times.

Custom operators follow the same pattern, which question 28 returns to.

4. What happens when you run kubectl apply on a Deployment?

kubectl sends the manifest to the API server, which authenticates the caller, checks RBAC, runs mutating then validating admission, and stores the Deployment in etcd. From there, a chain of watchers takes over.

Five steps after kubectl apply on a Deployment: the API server authenticates, authorizes and admits the object and stores it in etcd; the Deployment controller creates a ReplicaSet; the ReplicaSet controller creates Pods; the scheduler binds each Pod to a node; the kubelet starts the containers and ready Pods join the Service endpoints.

The Deployment controller creates or updates a ReplicaSet; the ReplicaSet controller creates Pod objects; the scheduler binds each Pod to a node; the kubelet on that node pulls images, sets up networking and volumes through the CNI and CSI plugins, and starts the containers.

Once readiness probes pass, the Pod's address appears in EndpointSlices and starts receiving Service traffic. No component calls another directly.

Workloads and Pods

5. When do you use a Deployment, StatefulSet, DaemonSet or Job?

  • Deployment: stateless replicas that are interchangeable, with rolling updates and rollback.
  • StatefulSet: replicas that need a stable name (db-0, db-1), a stable DNS entry through a headless Service, and their own PersistentVolumeClaim each, created and updated in order.
  • DaemonSet: one Pod per node, or per matching node, for log shippers, node exporters and CNI agents.
  • Job and CronJob: run to completion, with retries (backoffLimit), parallelism and a schedule for CronJob.

The follow-up for StatefulSets: running a database on Kubernetes is possible, but the StatefulSet only provides identity and storage. Replication, failover and backups come from the database or an operator.

6. Explain liveness, readiness and startup probes.

A readiness probe decides whether the Pod receives Service traffic; failing it removes the Pod from endpoints without restarting it. A liveness probe decides whether the container is stuck; failing it restarts the container.

A startup probe holds off the other two until a slow-starting app is up.

The common mistake is a liveness probe that checks dependencies such as the database. When the database blips, every Pod restarts at once and turns a short outage into a long one.

Liveness should check only that the process itself can respond; readiness can check what the Pod needs to serve.

7. What do resource requests and limits do, and what are QoS classes?

Requests are what the scheduler reserves on a node; limits are what the kernel enforces at runtime. A container over its CPU limit is throttled; a container over its memory limit is OOM-killed.

The QoS class follows from them. Guaranteed means every container has requests equal to limits for CPU and memory. Burstable means at least one request or limit is set. BestEffort means none are set.

Under memory pressure the kubelet evicts BestEffort Pods first and Guaranteed Pods last.

Many teams set memory limits equal to requests but leave CPU limits off, because CPU throttling causes latency spikes while spare CPU would otherwise sit idle.

8. What are native sidecar containers?

A sidecar is an init container with restartPolicy: Always. It starts before the app containers, keeps running alongside them, and stops after they exit. The feature went stable in Kubernetes 1.33, per the 1.33 release announcement.

spec:
  initContainers:
  - name: log-shipper
    image: fluent-bit:4
    restartPolicy: Always   # makes it a sidecar
  containers:
  - name: app
    image: shop-api:2.3

It fixed two old problems: a Job whose Pod never completed because a proxy sidecar kept running, and app containers starting before the mesh proxy was ready. Sidecars can also have probes.

9. How does a rolling update work, and how do you roll back?

The Deployment controller creates a new ReplicaSet and shifts Pods to it step by step. maxSurge sets how many extra Pods may exist during the update, and maxUnavailable how many may be missing; both default to 25%.

A new Pod counts as available only after its readiness probe passes and minReadySeconds elapses, which is what stops a broken version from replacing every Pod.

kubectl rollout undo deployment/api scales the previous ReplicaSet back up, and progressDeadlineSeconds marks a stuck rollout as failed.

Canary and blue-green releases need either two Deployments behind weighted routing or a tool such as Argo Rollouts; see our CI/CD interview guide for how those fit a pipeline.

10. What is a PodDisruptionBudget, and what does it not protect against?

A PDB sets how many Pods of an application may be down at once during voluntary disruptions: node drains, cluster upgrades and autoscaler scale-downs. The eviction API refuses to evict a Pod if that would break the budget.

It does not protect against involuntary disruptions such as a node crash or an OOM kill, and it is not a replica count.

A PDB of minAvailable: 1 on a one-replica Deployment blocks every drain, so the upgrade stalls; the right fix is more replicas, not a looser PDB.

11. How should a container shut down cleanly?

When a Pod is deleted, Kubernetes removes it from endpoints and sends SIGTERM to each container at the same time, then SIGKILL after terminationGracePeriodSeconds (30 seconds by default).

The app should stop accepting new work, finish in-flight requests and exit.

Because endpoint removal and SIGTERM race, a load balancer can still send requests for a moment after shutdown starts.

A short preStop sleep, which Kubernetes 1.34 made a stable built-in action instead of a shell command, gives the endpoint change time to propagate.

The app must also run as PID 1 or behind an init that forwards signals, or it never sees SIGTERM.

Scheduling and Scaling

12. What is the difference between taints and tolerations and node affinity?

A taint on a node repels Pods; only Pods with a matching toleration may schedule there (NoSchedule) or stay there (NoExecute).

Node affinity works the other way: it attracts a Pod to nodes with certain labels, as a hard requirement or a weighted preference.

Dedicating GPU nodes needs both: a taint so ordinary Pods stay off, and affinity so GPU Pods land there. A toleration alone lets a Pod onto a tainted node but does not send it there.

13. How do you spread replicas across zones?

With topologySpreadConstraints, keyed on topology.kubernetes.io/zone. maxSkew sets the allowed difference in Pod count between zones, and whenUnsatisfiable chooses between refusing to schedule (DoNotSchedule) and doing its best (ScheduleAnyway).

Pod anti-affinity can also keep replicas apart, but it scales poorly and is all-or-nothing per node or zone. Spread constraints are the modern answer.

Remember that the scheduler only places new Pods; it does not rebalance running ones, so a zone that recovers from an outage stays empty until Pods are recreated or the descheduler moves them.

14. Compare HPA, VPA and node autoscaling.

  • Horizontal Pod Autoscaler: changes the replica count from CPU, memory, custom or external metrics. KEDA extends it with event sources such as queue depth.
  • Vertical Pod Autoscaler: recommends or sets requests and limits from observed usage. With in-place resize (question 31) it can apply them without recreating Pods.
  • Cluster Autoscaler or Karpenter: add nodes when Pods are Pending for lack of capacity and remove underused ones. Karpenter provisions right-sized nodes directly instead of scaling fixed node groups.

HPA and VPA should not both act on CPU for the same workload, because each fights the other's changes. Node autoscalers react to requests, not usage, so Pods with no requests never trigger a scale-up.

15. A Pod is stuck in Pending. How do you find out why?

Run kubectl describe pod and read the Events. The scheduler records why no node fit, for example "0/6 nodes are available: 3 Insufficient memory, 3 node(s) had untolerated taint".

The usual causes: requests larger than any node's allocatable capacity, taints without tolerations, node affinity or topology spread that nothing satisfies, a PersistentVolumeClaim that cannot bind (wrong StorageClass, or a volume in another zone), or a ResourceQuota blocking creation, which shows as an error on the ReplicaSet instead of the Pod.

With a node autoscaler, check its logs too; it may refuse to add a node that would not fit the Pod either.

16. How do you debug a CrashLoopBackOff?

The container starts, exits, and the kubelet restarts it with an increasing delay. Start with kubectl logs pod --previous for the crashed container's output, then kubectl describe pod for the last state, exit code and reason.

  • Exit code 137 with reason OOMKilled: the memory limit is too low, or the app does not respect it (older JVMs, unbounded caches).
  • Exit code 1 or a stack trace: a config error, a missing Secret key or a dependency the app cannot reach at startup.
  • Killed by the liveness probe: the events say so; add a startup probe or loosen the timing.

kubectl debug with an ephemeral container attaches a shell with debugging tools to a running Pod whose image has none, which is the normal case with distroless images.

Networking

17. Explain the Service types, including headless Services.

ClusterIP (the default) gives a stable virtual IP inside the cluster. NodePort also opens a port on every node. LoadBalancer also asks the cloud provider for an external load balancer.

ExternalName is a DNS alias to a name outside the cluster.

A headless Service (clusterIP: None) has no virtual IP; DNS returns the Pod IPs directly, and with a StatefulSet each Pod gets its own record such as db-0.db.prod.svc.cluster.local.

Clients that need to reach a specific replica, such as database clients choosing the primary, rely on it.

Since 1.34, trafficDistribution: PreferSameZone or PreferSameNode keeps Service traffic local when an endpoint is available there, which cuts cross-zone data charges.

18. What does kube-proxy do, and which mode should a cluster use?

kube-proxy watches Services and EndpointSlices and programs each node's packet filtering so traffic to a Service IP reaches a backend Pod. It does not proxy traffic itself in the modern modes; the kernel does.

The modes are iptables (the long-time default), nftables (stable since 1.33, faster to update on large clusters) and ipvs, which Kubernetes 1.35 deprecated.

The 1.37 release notes expect ipvs to be off by default by 1.40 and removed by 1.43. Many clusters skip kube-proxy entirely with an eBPF CNI such as Cilium, which handles Service routing itself.

19. Ingress or Gateway API?

Gateway API for new work. Ingress is a single resource with host and path rules, and every controller extended it through its own annotations, so manifests were not portable.

Gateway API splits roles: platform teams own GatewayClass and Gateway (listeners, TLS, addresses), and app teams attach HTTPRoute or GRPCRoute objects, with header matching, traffic splitting and cross-namespace references built into the spec.

Ingress
  • One resource, host and path rules
  • Extras live in controller-specific annotations
Gateway API
  • Platform owns the Gateway, apps own their routes
  • Header matching and traffic weights in the spec itself

The Ingress API itself is not deprecated. What changed is that Ingress NGINX, the most common controller, is retired (question 33).

The project released Ingress2Gateway 1.0 in March 2026 to translate Ingress resources and common NGINX annotations into Gateway API objects.

20. How do NetworkPolicies work, and what is the common trap?

By default every Pod can reach every other Pod. A NetworkPolicy selects Pods and lists the ingress and egress traffic they allow; once any policy selects a Pod for a direction, everything not allowed in that direction is denied.

The usual baseline is a default-deny policy per namespace, then explicit allows.

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny
  namespace: shop
spec:
  podSelector: {}
  policyTypes: ["Ingress", "Egress"]
Two traps. The API server accepts NetworkPolicies even when the CNI plugin does not enforce them, so they can do nothing at all. And a default-deny egress policy also blocks DNS: every Pod in the namespace fails to resolve names until port 53 to CoreDNS is allowed.

21. What is a CNI plugin, and how would you choose one?

The Container Network Interface plugin gives each Pod an IP, connects it to the node's network and routes traffic between nodes. Kubernetes requires every Pod to reach every other Pod without NAT, and leaves how to the plugin.

Choices trade off between overlay networks (VXLAN or Geneve, simple and IP-efficient), native routing where Pods get routable VPC addresses (the AWS VPC CNI, Azure CNI with pod subnet), and eBPF dataplanes such as Cilium that add network policy, kube-proxy replacement and observability.

Managed platforms narrow the choice; AKS, for example, is moving clusters from kubenet to Azure CNI Overlay.

Storage and Config

22. How do PersistentVolumes, PersistentVolumeClaims and StorageClasses relate?

A PVC is a Pod's request for storage: size, access mode and a StorageClass. The StorageClass names a CSI driver and parameters, and the driver provisions a PersistentVolume that binds to the claim.

Static PVs created by an admin are the exception now.

Two settings come up in interviews. volumeBindingMode: WaitForFirstConsumer delays provisioning until the Pod is scheduled, so a zonal disk is created in the zone where the Pod runs instead of a random one. reclaimPolicy decides whether deleting the PVC deletes the disk (Delete) or keeps it (Retain).

23. What are the volume access modes?

ReadWriteOnce lets one node mount the volume read-write, which means several Pods on that node can share it. ReadWriteOncePod restricts it to a single Pod.

ReadOnlyMany and ReadWriteMany allow many nodes, and ReadWriteMany needs a file system such as NFS or a cloud file service; block disks do not support it.

A strong candidate knows that access modes describe what the volume supports and are enforced at mount time, and that ReadWriteOnce is the reason a Deployment with a disk and maxSurge above zero can hang during a rollout when the new Pod lands on another node.

24. Are Kubernetes Secrets secure?

Not by default. Secret values are base64-encoded, not encrypted, and anyone who can read Secrets in a namespace, or create a Pod that mounts them, can see them.

Hardening means encryption at rest in etcd through the API server's encryption configuration (ideally with a KMS provider), tight RBAC on get and list for Secrets, and avoiding Secrets in environment variables where crash dumps and logs can expose them.

Many teams keep the source of truth outside the cluster, in Vault or a cloud secret manager, and sync it in with the External Secrets Operator or the Secrets Store CSI driver.

Better still is no secret at all: workload identity federation lets a Pod's service account token stand in for cloud credentials.

Security

25. Explain Roles, ClusterRoles and their bindings.

A Role grants verbs on resources within one namespace; a ClusterRole grants them cluster-wide or on cluster-scoped resources such as nodes.

A RoleBinding grants a Role or a ClusterRole to users, groups or service accounts within one namespace; a ClusterRoleBinding grants a ClusterRole everywhere.

Binding a ClusterRole with a RoleBinding is the common pattern for reusing one definition, such as view, across namespaces.

Watch for escalation paths: create on Pods can mount any Secret in the namespace, and escalate, bind or impersonate let a user grant themselves more. kubectl auth can-i --list --as=system:serviceaccount:shop:api shows what an identity can actually do.

26. What replaced PodSecurityPolicy?

Pod Security Admission, built into the API server and stable since 1.25, the release that removed PodSecurityPolicy.

It enforces the three Pod Security Standards: privileged (no restrictions), baseline (blocks known privilege escalations such as host namespaces) and restricted (non-root, dropped capabilities, seccomp).

kubectl label namespace shop \
  pod-security.kubernetes.io/enforce=restricted \
  pod-security.kubernetes.io/warn=restricted

Each namespace sets a level per mode: enforce rejects, audit logs and warn tells the user. Rules beyond the three standards, such as allowed registries or required labels, come from ValidatingAdmissionPolicy, Kyverno or OPA Gatekeeper.

27. How do service account tokens work today?

Pods get a projected, bound token from the TokenRequest API: it has an audience and an expiry, is tied to the Pod's lifetime and is rotated by the kubelet.

Since 1.24, Kubernetes no longer creates long-lived token Secrets for every service account automatically.

Good practice is a dedicated service account per workload, automountServiceAccountToken: false for Pods that never call the API, and minimal RBAC for the rest.

Cloud workload identity (IRSA or EKS Pod Identity, GKE Workload Identity, Entra Workload ID) builds on the same tokens, so the Pod needs no cloud keys.

Extending Kubernetes

28. What are CRDs and operators?

A CustomResourceDefinition adds a new resource type to the API, with an OpenAPI schema for validation, so kubectl get postgresclusters works like any built-in type. On its own, a CRD only stores data.

An operator is a controller that reconciles those custom resources, encoding the operational knowledge of a system: creating replicas, running backups, handling failover and upgrades.

Good operators set status.conditions, use finalizers to clean up external resources before deletion, use owner references so garbage collection removes children, and are safe to run repeatedly.

Most are built with Kubebuilder or the Operator SDK on controller-runtime.

29. When would you write an admission webhook instead of an admission policy?

Only when a policy cannot express the rule. ValidatingAdmissionPolicy, stable since 1.30, and MutatingAdmissionPolicy, stable since 1.36, run CEL expressions inside the API server, with no extra service to deploy, secure and keep available.

validations:
- expression: "object.spec.replicas <= 5"
  message: "replicas must be 5 or fewer in this namespace"

A webhook is an HTTPS service the API server calls on each matching request. It can call external systems and run any logic, but if it is down and its failurePolicy is Fail, matching requests fail cluster-wide.

That risk is the main reason to prefer in-process policies.

30. What changed in Helm 4?

Helm 4.0.0 was released on November 12, 2025, the first major version since Helm 3.

The release notes highlight a redesigned plugin system with WebAssembly plugins, post-renderers moved into plugins, server-side apply support, waiting based on kstatus, content-based chart caching and logging through Go's slog.

Charts with apiVersion: v2, most charts in use, keep working, but CLI flags, output and the Go SDK changed.

The interview question behind it is the Helm versus Kustomize choice: Helm for packaging and distributing configurable apps, Kustomize for overlaying environment differences on plain manifests, and often both, with Argo CD or Flux applying the result.

What Changed Recently

Apr 23, 2025
1.33: native sidecars and nftables kube-proxy go stable
Aug 27, 2025
1.34: core Dynamic Resource Allocation goes GA
Dec 17, 2025
1.35: in-place Pod resize GA, cgroup v1 off by default, ipvs deprecated
Mar 24, 2026
Ingress NGINX retired
Apr 22, 2026
1.36: MutatingAdmissionPolicy GA, gitRepo volumes disabled, externalIPs deprecated
Aug 26, 2026
1.37: HPA scale to zero in beta, KYAML stable, kube-dns deprecated

31. What is in-place Pod resize?

Graduated to GA in 1.35, per the 1.35 release announcement, it lets you change a running container's CPU and memory requests and limits without recreating the Pod.

Each container's resizePolicy says whether a change needs a container restart; CPU changes usually do not, while memory changes for runtimes that size their heap at startup, such as the JVM, often should.

It matters for stateful and long-warming workloads that used to lose caches or connections on every vertical scale, and it lets VPA apply recommendations without evictions.

If the node lacks room, the resize stays pending rather than moving the Pod.

32. What do the cgroup v1 and containerd 1.x changes mean for a cluster upgrade?

Since 1.35, the kubelet's failCgroupV1 setting defaults to true, so a node still on cgroup v1 fails to start unless an operator sets it back to false as a temporary override.

Memory QoS and some newer resource features work only on cgroup v2, and the project plans to remove v1 support.

1.35 was also the last release to support containerd 1.x; 1.36 and later need containerd 2.0 or newer, and the kubelet_cri_losing_support metric flags nodes at risk.

Both are node-image checks to run before an upgrade, and old self-managed nodes on older Linux distributions are where they bite.

33. Ingress NGINX is retired. What should a team running it do?

Per the retirement announcement, the project stopped releases, bug fixes and security fixes on March 24, 2026. Existing installs keep running and the images remain available, but the next CVE will not be patched.

In March 2025, the IngressNightmare vulnerabilities (CVE-2025-1974 among them) showed how exposed an unpatched ingress controller is.

The plan: inventory Ingress resources and the NGINX-specific annotations they rely on, choose a Gateway API implementation (Envoy Gateway, Istio, Cilium, NGINX Gateway Fabric, a cloud provider's gateway), translate with Ingress2Gateway, then run both side by side and shift DNS.

Alternatively, move to another maintained Ingress controller, and plan Gateway API later.

34. Can the HorizontalPodAutoscaler scale to zero now?

Yes, in beta and enabled by default since 1.37, for HPAs driven by object or external metrics. Setting spec.minReplicas: 0 lets an idle queue consumer or GPU worker scale down to nothing and come back when the metric returns.

It does not work with CPU or memory metrics, because those need running Pods to report anything.

While holding a workload at zero, the HPA sets a ScaledToZero condition, which separates "scaled to zero by the HPA" from "scaled to zero by a person".

Before this, scale to zero meant KEDA or Knative; KEDA still adds the event sources and activation logic that the HPA lacks.

35. What is Dynamic Resource Allocation?

DRA is the API for requesting specialized hardware such as GPUs, network interfaces and accelerators, and its core went GA in 1.34.

Instead of an opaque count like nvidia.com/gpu: 1, a Pod references a ResourceClaim, and vendors publish devices with attributes in ResourceSlices, so a claim can ask for "a GPU with at least 40 GB of memory" and the scheduler matches it.

Later releases added prioritized alternatives, admin access and device taints, several of which went stable in 1.36 and 1.37.

It matters for any team running AI workloads on Kubernetes, where device plugins could not express sharing, partitioning or topology.

Signs of a Strong Answer

  • They start any troubleshooting answer with kubectl describe and events, not with a guess.
  • They keep dependency checks out of liveness probes and can say what outage that prevents.
  • They explain requests versus limits in terms of scheduling versus enforcement, and have an opinion on CPU limits backed by an incident.
  • They know NetworkPolicies need an enforcing CNI and that default-deny egress breaks DNS.
  • They have a migration plan for Ingress NGINX, cgroup v1 or containerd 1.x, or have already run one.
  • They reach for built-in features (native sidecars, admission policies, spread constraints) before adding a new tool.

Hiring Kubernetes Engineers

Engineers who have run Kubernetes through upgrades and incidents, not just deployed to it, are the hardest DevOps profile to find.

Second Talent matches companies with pre-vetted Kubernetes engineers and DevOps engineers from Asia, screened with questions like these.

Tell us the platform and we send a shortlist within 24 hours. Start hiring, or continue with our Docker and Terraform interview guides.

Ready to hire? Hire Kubernetes Engineers: vetted AI-native talent, with first profiles in 24 hours.

Get developers who ship with AI agents.

Starts at $25/Hour.

Start Hiring

$0 cost until you hire