Kubernetes: Follow-Up Questions Interviewers Ask (and How to Answer Them)
When a candidate drops Kubernetes during a system-design interview, the interviewer instantly knows the candidate is comfortable with container orchestration. The next step is to see whether they truly understand how the platform fits into a larger architecture, not just that they can name a few objects.
Interviewers therefore probe Kubernetes to uncover three things: operational depth, scaling strategy, and cost-aware design choices. Below are nine follow-up questions that typically rise from the first hint to the hardest, each paired with a concise answer you can deliver in an interview.
1. What does a typical pod lifecycle look like?
I would say: "When a pod is created, the API server stores its spec in etcd. The scheduler then picks a node that satisfies the pod’s resource requests and affinity rules. The kubelet on that node receives the pod via the watch API, pulls the container image, and hands it to the container runtime (usually containerd). The pod moves through Pending → Running once the containers start. If a container crashes, the kubelet follows the restartPolicy – Always for most workloads – and relaunches it. When the pod is deleted, the kubelet sends a SIGTERM, waits the terminationGracePeriodSeconds (default 30 s), then SIGKILL if needed, and finally removes the pod from the node’s status."
2. How do you handle rolling updates without downtime?
I answer: "Kubernetes uses a Deployment object that creates a ReplicaSet. During a rolling update, the Deployment increments the ReplicaSet’s revision and gradually scales up the new ReplicaSet while scaling down the old one. By default it rolls out 25 % of pods at a time and respects the maxUnavailable and maxSurge settings. For a service with 8 replicas, that means at most two pods are out of service while two newer pods are added, ensuring the total capacity never drops below six. The readiness probe guarantees traffic only reaches pods that have passed their health check."
3. What is the difference between a Service of type ClusterIP and LoadBalancer?
I would explain: "ClusterIP creates an internal virtual IP that is only reachable within the cluster. It routes traffic to the backing pods via kube-proxy (iptables or IPVS). LoadBalancer asks the underlying cloud provider (e.g., AWS ELB) to provision an external load balancer and assign a public IP. The external LB forwards traffic to the cluster’s nodes (through a NodePort, or straight to pod IPs on some clouds) and on to the same pods, so the Service abstraction stays the same, but LoadBalancer adds a cost-incurring external endpoint and typically a health-check configuration on the cloud side."
4. How do you size the cluster for a workload that receives 200 requests per second?
My answer: "First I estimate the per-request CPU and memory usage. Suppose a request consumes 20 ms of CPU on a 2 GHz core, that’s 0.02 CPU-seconds. At 200 rps the CPU demand is 200 × 0.02 = 4 CPU cores. Adding a 30 % safety buffer brings it to roughly 5.2 cores. If each node runs 8 vCPUs, a single node can handle the load, but I would still provision two nodes for high availability. Memory is sized similarly; if each request uses 50 MiB, the total is 10 GiB, so a node with 32 GiB comfortably covers the workload plus headroom."
5. What are the trade-offs of using StatefulSet vs Deployment for a database?
I respond: "A StatefulSet gives each pod a stable network identity and ordered, graceful scaling. This is crucial for databases that rely on predictable hostnames for replication or leader election. It also ensures persistent volume claims are bound one-to-one with pods, preserving data across restarts. A Deployment offers faster rollout and can replace pods arbitrarily, which is fine for stateless services but risky for a DB because pod replacement could break replication topology. The downside of StatefulSet is slower scaling – pods are added sequentially – and rolling updates also go one pod at a time in order, so rollouts take longer."
6. How do you monitor pod health and troubleshoot a failing pod?
I say: "I start with the built-in liveness and readiness probes. If a pod repeatedly fails the readiness check, I inspect the pod logs via kubectl logs. For deeper insight I enable metrics-server to view CPU/memory usage, and I use kubectl describe pod to see events such as OOMKilled or image pull errors. If the issue is node-related, I check the node’s kubelet logs and the cloud provider’s health dashboard. For network problems, I can exec into the pod and run curl or nslookup to verify service DNS and connectivity."
7. Explain how you would implement canary deployments with Kubernetes.
My concise answer: "I create two Deployments – stable and canary – each with its own label selector. An Ingress or Service uses a weighted traffic split, often via a service mesh like Istio, where 95 % of traffic goes to the stable version and 5 % to the canary. I monitor key metrics (error rate, latency) for the canary pods. If they stay within thresholds for, say, 10 minutes, I increase the weight to 20 % and repeat until the canary reaches 100 %. Finally I delete the old stable Deployment. This approach isolates risk without changing the core Service definition."
8. How do you secure inter-pod communication?
I answer: "Kubernetes offers NetworkPolicies to restrict which pods can talk to each other. By default, all pods can communicate, so I define a policy that allows traffic only from specific namespaces or label selectors. For encryption in transit, I enable TLS at the application layer and optionally use service-mesh sidecars (e.g., Linkerd) that automate mTLS between pods. Additionally, I run the API server with RBAC and apply the Pod Security Standards through Pod Security Admission (the older PodSecurityPolicy was removed in Kubernetes 1.25) to enforce least-privilege settings, such as dropping unnecessary capabilities."
9. What considerations change when you move from a single-region cluster to a multi-region, globally-distributed architecture?
I would elaborate: "First, latency becomes a driver – I place clusters in each region and use a global DNS or anycast load balancer to route users to the nearest endpoint. Data replication must be eventual or strongly consistent depending on the use case; for strongly consistent data I might use a distributed database like CockroachDB that runs on Kubernetes across regions, accepting higher write latency. I also need to handle cross-region traffic costs, so I keep most traffic intra-region and only synchronize state asynchronously. Finally, I configure Federated or Cluster-API to manage multiple clusters, and I set up centralized observability (e.g., Prometheus federation) to monitor all regions from a single pane."
How to practice this
- Review the worked design for a container orchestrator in the System Design AI library; every component on the board can be clicked for its notes.
- Write your own answers on a blank canvas, mimicking the interview flow from basic lifecycle to multi-region design.
- Use the AI coach to get feedback on clarity, depth, and whether you included concrete numbers or examples.
What separates a senior answer from a staff answer?
A senior candidate will correctly describe the mechanics and give sensible numbers. A staff candidate goes further: they discuss the impact on the entire system, trade-offs across cost, reliability, and operational complexity, and they anticipate downstream effects (e.g., how a canary rollout interacts with autoscaling policies). Staff answers also embed best-practice patterns—like using a service mesh for mTLS or leveraging cluster-API for multi-region management—showing a holistic view of the platform.
Questions people ask
Why do interviewers ask follow-up questions about Kubernetes?
They want to confirm that you know more than the buzzword. Follow-ups reveal whether you understand pod lifecycles, scaling mechanisms, and operational trade-offs, which are critical for designing real-world systems.
What is the most common mistake candidates make about Kubernetes scaling?
Many assume adding more pods automatically solves latency. In reality, you must consider node limits, network policies, and the impact on downstream services. A balanced answer includes resource estimates and safety buffers.
How much extra capacity should I leave when sizing a Kubernetes cluster?
A typical rule of thumb is to add 20-30 % headroom for traffic spikes and node failures. For example, if calculations show 5 CPU cores needed, provision around 6-7 cores across at least two nodes.
Can I use Kubernetes without a cloud provider?
Yes. You can run Kubernetes on bare metal or on-premise VMs. The main difference is that you must provide your own load balancer, storage classes, and networking plugins instead of relying on managed services.