roadmap
- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
Explain how Kubernetes runs, scales and heals containerized workloads, and why it behaves that way. Covers workloads and networking, scheduling, security, observability, Helm and GitOps delivery, and operators.
662 of 662 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 662 new. 0 cut, outside your plan.
Few jobs are titled Kubernetes, so the subject arrives inside other loops. DevOps, SRE and platform interviews usually give it a technical round of its own, often hands-on: a cluster or a manifest is broken, and you talk through the `kubectl` commands that find out why. In a backend loop it usually surfaces only when a system design answer reaches the question of how the service is deployed, mostly from middle level up, and the follow-ups stay near the objects that service depends on. The questions start from a symptom and end at the component behind it. A pod sits in Pending, and its events say why: no node has enough allocatable memory left for its request, or each node carries a taint the pod does not tolerate. A latency-sensitive service is throttled while its average CPU looks low, because the kernel enforces a CPU limit over short accounting periods, not on the average. Requests fail briefly during rollouts, because a terminating pod gets SIGTERM while other nodes still route traffic to it, and a short `preStop` delay is the usual fix. Depth shows in how many follow-ups an answer survives. Asked who recreates a deleted pod, most candidates say the Deployment; the next questions want the ReplicaSet controller, its watch on the API server, the scheduler that binds the replacement and the kubelet that starts it. Senior and staff candidates are more often handed one operation or one design: a control-plane upgrade within the supported version skew, an etcd restore, a tenancy model for many teams on one cluster.
Before any cluster object appears, the plan spends its opening module on the container itself. The [isolation model](/topics/cloud-containers-concepts-isolation) shows what a container is to the kernel and the [image format](/topics/cloud-containers-concepts-image-model) what a node actually pulls; CPU throttling, memory kills and pull failures later in the plan are these mechanisms seen through Kubernetes. Core Concepts puts the [control plane](/topics/cloud-kubernetes-architecture) ahead of any workload on purpose: once an object is understood as a record a controller watches and corrects, a Deployment, a Service and an autoscaler become three cases of one idea. [API object conventions](/topics/cloud-kubernetes-api-objects) supply the grammar they share: selectors, owner references, who owns a field after an apply. With the loop understood, the plan gives it something to run. [Pods and workloads](/topics/cloud-kubernetes-pods-workloads) carry the most weight: which controller owns which pod, how probes choose between traffic and a restart, how a rollout replaces pods without dropping requests. After [settings and credentials](/topics/cloud-kubernetes-config-secrets), networking and storage supply the rest of what a pod needs from outside itself: [Services](/topics/cloud-kubernetes-services-networking) with the DNS, proxying and ingress in front of them, and [volumes](/topics/cloud-kubernetes-storage-volumes) that outlive a pod. From one workload the plan widens to the cluster. [Scheduling and scaling](/topics/cloud-kubernetes-scaling-scheduling) decide where pods land, how many run and how many may be taken away at once. Access & Isolation asks who may do any of it, following an API request through authentication, authorization and admission in [security](/topics/cloud-kubernetes-security) before quotas keep one team from starving another. Monitoring & Debugging opens with instruments that are not specific to Kubernetes, the general telemetry signals and [Prometheus](/topics/cloud-prometheus), so that [troubleshooting](/topics/cloud-kubernetes-troubleshooting) can read metrics, logs and events together; it is where the earlier modules are tested as one. The final stretch is about running Kubernetes for other people. [Helm](/topics/cloud-helm-chart-structure) comes as a chart's layout first and its templating second, since a failed render is easier to read once you know which file supplies which value, and [GitOps](/topics/cloud-cicd-gitops) points the reconciliation idea from the opening at a Git repository. [Operators](/topics/cloud-kubernetes-operators-crds) extend the API with your own types and controllers, and the plan closes on [cluster lifecycle](/topics/cloud-kubernetes-cluster-lifecycle), from upgrades to etcd backups, and on [adoption](/topics/cloud-kubernetes-adoption), which asks whether a workload belongs on a cluster at all.
A backend engineer whose service merely runs on a cluster meets questions close to the workload: pods, probes, rollouts, Services and config. With importance cut to must know, Running Applications and Networking & Storage hold most of what a deployment conversation asks, and level can stay at its full range, because the junior object-model questions are the ones a backend round borrows. Senior platform and SRE candidates work the other way: raise the bottom of the level range to your own band, switch study order to by topics so the questions arrive module after module, and spend the hours on scheduling, security, troubleshooting and cluster operations. A few months out, a throwaway local cluster from kind or minikube is worth more than another read. Break it deliberately, with a selector that matches nothing, a memory limit set too low, a node drained with no disruption budget, so that the hands-on round shows you events you have already seen. The plan explains how image layers and registries behave, not how to write a Dockerfile; that is the [Docker roadmap](/roadmaps/docker). And the cluster is one part of a platform job: Linux administration, infrastructure as code and building CI pipelines sit in the [DevOps / SRE Engineer roadmap](/roadmaps/devops), the one to take when the posting is for the whole role.
Few jobs are titled Kubernetes, so the subject arrives inside other loops. DevOps, SRE and platform interviews usually give it a technical round of its own, often hands-on: a cluster or a manifest is broken, and you talk through the kubectl commands that find out why. In a backend loop it usually surfaces only when a system design answer reaches the question of how the service is deployed, mostly from middle level up, and the follow-ups stay near the objects that service depends on.
The questions start from a symptom and end at the component behind it. A pod sits in Pending, and its events say why: no node has enough allocatable memory left for its request, or each node carries a taint the pod does not tolerate. A latency-sensitive service is throttled while its average CPU looks low, because the kernel enforces a CPU limit over short accounting periods, not on the average. Requests fail briefly during rollouts, because a terminating pod gets SIGTERM while other nodes still route traffic to it, and a short preStop delay is the usual fix.
Depth shows in how many follow-ups an answer survives. Asked who recreates a deleted pod, most candidates say the Deployment; the next questions want the ReplicaSet controller, its watch on the API server, the scheduler that binds the replacement and the kubelet that starts it. Senior and staff candidates are more often handed one operation or one design: a control-plane upgrade within the supported version skew, an etcd restore, a tenancy model for many teams on one cluster.
Before any cluster object appears, the plan spends its opening module on the container itself. The isolation model shows what a container is to the kernel and the image format what a node actually pulls; CPU throttling, memory kills and pull failures later in the plan are these mechanisms seen through Kubernetes. Core Concepts puts the control plane ahead of any workload on purpose: once an object is understood as a record a controller watches and corrects, a Deployment, a Service and an autoscaler become three cases of one idea. API object conventions supply the grammar they share: selectors, owner references, who owns a field after an apply.
With the loop understood, the plan gives it something to run. Pods and workloads carry the most weight: which controller owns which pod, how probes choose between traffic and a restart, how a rollout replaces pods without dropping requests. After settings and credentials, networking and storage supply the rest of what a pod needs from outside itself: Services with the DNS, proxying and ingress in front of them, and volumes that outlive a pod.
From one workload the plan widens to the cluster. Scheduling and scaling decide where pods land, how many run and how many may be taken away at once. Access & Isolation asks who may do any of it, following an API request through authentication, authorization and admission in security before quotas keep one team from starving another.
Monitoring & Debugging opens with instruments that are not specific to Kubernetes, the general telemetry signals and Prometheus, so that troubleshooting can read metrics, logs and events together; it is where the earlier modules are tested as one. The final stretch is about running Kubernetes for other people. Helm comes as a chart's layout first and its templating second, since a failed render is easier to read once you know which file supplies which value, and GitOps points the reconciliation idea from the opening at a Git repository. Operators extend the API with your own types and controllers, and the plan closes on cluster lifecycle, from upgrades to etcd backups, and on adoption, which asks whether a workload belongs on a cluster at all.
A backend engineer whose service merely runs on a cluster meets questions close to the workload: pods, probes, rollouts, Services and config. With importance cut to must know, Running Applications and Networking & Storage hold most of what a deployment conversation asks, and level can stay at its full range, because the junior object-model questions are the ones a backend round borrows.
Senior platform and SRE candidates work the other way: raise the bottom of the level range to your own band, switch study order to by topics so the questions arrive module after module, and spend the hours on scheduling, security, troubleshooting and cluster operations. A few months out, a throwaway local cluster from kind or minikube is worth more than another read. Break it deliberately, with a selector that matches nothing, a memory limit set too low, a node drained with no disruption budget, so that the hands-on round shows you events you have already seen.
The plan explains how image layers and registries behave, not how to write a Dockerfile; that is the Docker roadmap. And the cluster is one part of a platform job: Linux administration, infrastructure as code and building CI pipelines sit in the DevOps / SRE Engineer roadmap, the one to take when the posting is for the whole role.