Kubernetes Roadmap: From Pods to Platform Engineering
What you build: an 8-level Kubernetes roadmap from pods to platform engineering, with a real script that checks every level on GKE (pod, service, config, probes, HPA, RBAC, Helm, as code).

✍️ Translate this blog into Hindi, Tamil or Telugu
Kubernetes has a famously steep learning curve, mostly because people try to learn everything at once: pods, operators, service mesh and GitOps in one week. This roadmap splits the path into eight levels, from your first pod to platform engineering, and gives each level one small task you can check on a real cluster. The lab in this post runs all eight checks with one script on Google Kubernetes Engine (GKE) and prints PASS or FAIL per level, so you always know where you stand.
Who it is for: developers, sysadmins and DevOps learners starting or restarting Kubernetes. Time: about 4 to 6 months for the whole roadmap at 6 to 8 hours a week; about 30 minutes for this lab. Cost: the lab needs a small GKE cluster for about half an hour (a small compute cost); delete it right after.
The level check was run for real by the CareerByteCode Team on a GKE cluster in a fresh Google Cloud project, and every output is the real one we got.
🎓⭐ Recommended by CareerByteCode · Live trainingAWS Cloud Architecture and AIOps Bootcampโน10,620See the training →Part A: the eight levels

| Level | You learn | The check |
|---|---|---|
| 1. Pods | containers, kubectl run, logs, describe | a pod reaches Ready |
| 2. Deployments and Services | replicas, rollouts, stable names | 2 replicas answer through a Service |
| 3. Configuration | ConfigMaps, Secrets, env and files | the app reads a ConfigMap value and a Secret |
| 4. Health and resources | probes, requests and limits, zero-downtime rollouts | a readiness probe and requests roll out cleanly |
| 5. Scaling | metrics, HorizontalPodAutoscaler | an HPA manages the deployment (2 to 5 pods) |
| 6. Security | RBAC, service accounts, least privilege | a viewer account may list pods but not delete them |
| 7. Packaging | Helm charts, values, releases | a Helm release is deployed |
| 8. Everything as code (platform) | YAML in Git, GitOps, policies, golden paths | the live state is exported as YAML and validated by the API server |
Real-life example: learning to drive. Level 1 is starting the engine, level 2 is driving in a quiet street, levels 3 to 6 are traffic rules, mirrors and safety, level 7 is driving a loaded truck, and level 8 is running the whole delivery company with rules everyone follows.
Platform engineering (level 8 and beyond) is building that "company": self-service templates, GitOps, policy as code and observability, so other developers can ship safely without becoming Kubernetes experts themselves.
Part B: the lab, check all eight levels
Before you start
- A Google Cloud account with billing and a project. This lab uses a small GKE cluster (not free).
- Open Cloud Shell (the
>_icon at the top right of the console); it haskubectlandhelm. Create the cluster (about 5 minutes):
export PROJECT_ID="your-project-id"
gcloud config set project $PROJECT_ID
gcloud services enable container.googleapis.com
gcloud container clusters create lab-cluster --zone=us-east1-b --num-nodes=2 \
--machine-type=e2-standard-4 --disk-type=pd-standard --disk-size=50- Save the level check as
levels.shin a folder~/lab320(mkdir -p ~/lab320 && cd ~/lab320, thennano levels.sh). Each level is a few lines: do one real task, then check it.
#!/bin/bash
# levels.sh: one small, real task per level of the Kubernetes roadmap. Prints PASS or FAIL for each level.
# Run it in an empty namespace: kubectl create ns roadmap && kubectl config set-context --current --namespace=roadmap
ok() { printf "PASS level %-2s %s\n" "$1" "$2"; }
no() { printf "FAIL level %-2s %s\n" "$1" "$2"; FAILED=1; }
FAILED=0
# Level 1: a pod runs
kubectl run hello --image=nginx:1.27 > /dev/null && kubectl wait pod/hello --for=condition=Ready --timeout=120s > /dev/null && ok 1 "a pod runs (kubectl run, wait)" || no 1 "pod"
# Level 2: a deployment with 2 replicas behind a service answers
kubectl create deployment web --image=nginx:1.27 --replicas=2 > /dev/null && kubectl expose deploy web --port=80 > /dev/null && kubectl rollout status deploy/web --timeout=120s > /dev/null
L2=no; for i in 1 2 3 4 5 6; do kubectl run check --image=busybox:1.36 --rm -i --restart=Never -- wget -qO- -T 3 http://web 2>/dev/null | grep -q "Welcome to nginx" && L2=yes && break; sleep 5; done; [ $L2 = yes ] && ok 2 "deployment + service answer (2 replicas)" || no 2 "service"
# Level 3: config and secrets reach the app
kubectl create configmap cfg --from-literal=MODE=prod > /dev/null && kubectl create secret generic sec --from-literal=token=lab-only > /dev/null
kubectl run cfg-test --image=busybox:1.36 --restart=Never --overrides='{"spec":{"containers":[{"name":"t","image":"busybox:1.36","command":["sh","-c","echo $MODE $TOKEN"],"env":[{"name":"MODE","valueFrom":{"configMapKeyRef":{"name":"cfg","key":"MODE"}}},{"name":"TOKEN","valueFrom":{"secretKeyRef":{"name":"sec","key":"token"}}}]}]}}' > /dev/null
kubectl wait pod/cfg-test --for=jsonpath='{.status.phase}'=Succeeded --timeout=90s > /dev/null && [ "$(kubectl logs cfg-test)" = "prod lab-only" ] && ok 3 "ConfigMap and Secret reach the app" || no 3 "config"
# Level 4: health checks and resources
kubectl patch deploy web --type=json -p '[{"op":"add","path":"/spec/template/spec/containers/0/readinessProbe","value":{"httpGet":{"path":"/","port":80}}},{"op":"add","path":"/spec/template/spec/containers/0/resources","value":{"requests":{"cpu":"50m","memory":"64Mi"}}}]' > /dev/null && kubectl rollout status deploy/web --timeout=120s > /dev/null && ok 4 "readiness probe + requests, rolled out with no downtime" || no 4 "probes"
# Level 5: autoscaling
kubectl autoscale deploy web --cpu=60% --min=2 --max=5 > /dev/null; L5=no; for i in $(seq 1 48); do kubectl get hpa web -o jsonpath='{.status.currentReplicas}' | grep -qE "^[2-5]$" && L5=yes && break; sleep 5; done; [ $L5 = yes ] && ok 5 "HPA manages the deployment (2 to 5 pods)" || no 5 "hpa"
# Level 6: RBAC, least privilege inside the cluster
kubectl create serviceaccount viewer > /dev/null && kubectl create role pod-reader --verb=get,list --resource=pods > /dev/null && kubectl create rolebinding viewer-reads --role=pod-reader --serviceaccount=roadmap:viewer > /dev/null
[ "$(kubectl auth can-i list pods --as=system:serviceaccount:roadmap:viewer)" = yes ] && [ "$(kubectl auth can-i delete pods --as=system:serviceaccount:roadmap:viewer)" = no ] && ok 6 "RBAC: viewer may list pods, may not delete" || no 6 "rbac"
# Level 7: packaging with Helm
helm upgrade --install demo oci://ghcr.io/stefanprodan/charts/podinfo --version 6.7.1 --wait --timeout 5m > /dev/null 2>&1 && [ "$(helm status demo -o json | python3 -c 'import json,sys; print(json.load(sys.stdin)["info"]["status"])')" = deployed ] && ok 7 "a Helm release is deployed" || no 7 "helm"
# Level 8: everything is described as code (export and re-apply is a no-op)
kubectl get deploy web -o yaml > web-export.yaml && kubectl apply -f web-export.yaml --dry-run=server > /dev/null 2>&1 && ok 8 "state exported as YAML and validated by the API server" || no 8 "as code"
exit $FAILEDStep 1: connect and use an empty namespace
# Connect to the cluster and make an empty namespace for the level check
gcloud container clusters get-credentials lab-cluster --zone=us-east1-b > /dev/null 2>&1
kubectl create namespace roadmap > /dev/null && kubectl config set-context --current --namespace=roadmap > /dev/null && echo "namespace: $(kubectl config view --minify -o jsonpath='{..namespace}')"
kubectl get nodes --no-headers | awk '{print $1, $2, $5}'namespace: roadmap
gke-lab-cluster-default-pool-05c62ce7-0cmh Ready v1.36.4-gke.2377000
gke-lab-cluster-default-pool-05c62ce7-p9ld Ready v1.36.4-gke.2377000Step 2: run the level check
# Run the level check: one real task per roadmap level
cd ~/lab320
chmod +x levels.sh && time ./levels.shPASS level 1 a pod runs (kubectl run, wait)
PASS level 2 deployment + service answer (2 replicas)
PASS level 3 ConfigMap and Secret reach the app
PASS level 4 readiness probe + requests, rolled out with no downtime
PASS level 5 HPA manages the deployment (2 to 5 pods)
PASS level 6 RBAC: viewer may list pods, may not delete
PASS level 7 a Helm release is deployed
PASS level 8 state exported as YAML and validated by the API server
real 1m25.583s
user 0m4.469s
sys 0m2.053s
Read it like a progress report. If a level fails on your cluster, that level is your next week of study: open the matching lab below, then run the check again.
Step 3: what the levels created
# What the eight levels created, in one view
kubectl get deploy,svc,hpa,configmap,secret,sa,role,rolebinding --no-headers 2>/dev/null | awk '{print $1}' | grep -vE "kube-root-ca|default$" | sortconfigmap/cfg
deployment.apps/demo-podinfo
deployment.apps/web
horizontalpodautoscaler.autoscaling/web
role.rbac.authorization.k8s.io/pod-reader
rolebinding.rbac.authorization.k8s.io/viewer-reads
secret/sec
secret/sh.helm.release.v1.demo.v1
service/demo-podinfo
service/web
serviceaccount/viewerDeployments, Services, an HPA, ConfigMaps, Secrets, a service account, a Role and a RoleBinding: the everyday objects of Kubernetes, all created by the eight small tasks.

Part C: the study plan, level by level
| Level | Weeks | Study with |
|---|---|---|
| 1-2 | 3 | the Kubernetes basics docs, then our CKAD Practice: 20 Developer Tasks on a Real Cluster, tasks 1 to 4 |
| 3-4 | 3 | ConfigMaps, Secrets, probes and resources (CKAD practice tasks 5 to 8) |
| 5 | 2 | metrics and autoscaling: Prometheus and Grafana on Kubernetes |
| 6 | 2 | RBAC and identity, plus cloud IAM: Google Cloud IAM for Beginners |
| 7 | 2 | Helm: write a chart, test it, publish it |
| 8 | 4 | GitOps and a service mesh: Argo CD on Kubernetes, Istio for Beginners |
| Beyond | ongoing | AI workloads on Kubernetes: Run Your Own LLM on Kubernetes with Ollama |
Certifications that match: CKAD after level 5 (developer focus), CKA after level 6 (administrator focus), CKS later (security).
POC: prove it works
🎓⭐ Recommended by CareerByteCode · Live trainingAzure Cloud Architecture and AIOps Bootcampโน10,620See the training →- One script ran a real task for each of the eight levels on GKE and printed PASS for all eight.
- The namespace held the objects every level created, from a pod to a Role and RoleBinding.
- Each level maps to a study block and a tested lab.
Quiz task: check what you learned
- Which level does a readiness probe belong to, and why? (Answer: level 4; it keeps traffic away from pods that are not ready, so rollouts have no downtime.)
kubectl auth can-i delete pods --as=...saysno. Which level does that prove? (Answer: level 6, RBAC and least privilege.)- What does platform engineering add on top of level 8? (Answer: self-service templates, GitOps, policies and observability so other teams can ship safely.)
- Your HPA check fails. What do you check first? (Answer: that the deployment has CPU requests (level 4) and that metrics are available.)
- Which certification fits after level 5? (Answer: CKAD.)
Clean up (delete everything)
# Clean up: delete the namespace (everything inside it goes too)
cd ~/lab320
helm uninstall demo -n roadmap > /dev/null 2>&1; kubectl config set-context --current --namespace=default > /dev/null
kubectl delete namespace roadmap --wait=true 2>&1 | tail -1
rm -f web-export.yamlnamespace "roadmap" deletedThen delete the cluster when you finish:
gcloud container clusters delete lab-cluster --zone=us-east1-b --quietFAQ
Do I need to learn Docker first? Know the basics (image, container, registry, docker run). You do not need deep Docker skills to start level 1.
Minikube, kind or a cloud cluster? Local tools are great for levels 1 to 4. Cloud clusters (like GKE here) teach the real things: load balancers, autoscaling, cloud identity and storage.
How long until I can apply for Kubernetes jobs? After levels 1 to 6 and one project (about 3 months at a steady pace) you can apply for junior roles; CKAD or CKA helps.
What is the difference between DevOps and platform engineering? DevOps is a way of working (teams own build, deploy and operate). Platform engineering builds the internal products (templates, pipelines, clusters) that make that easy for everyone.
Should I learn operators? Later. Use operators (level 7 to 8) long before you write one. Writing operators is a specialist skill.
Why GKE? Managed Kubernetes removes the control-plane work so you can focus on the levels. The same checks run on EKS, AKS or a local cluster.
Troubleshooting
| You see | Why | Fix |
|---|---|---|
FAIL level 2 service | The Service had no ready endpoints yet | Wait a few seconds and retry; check kubectl get endpoints |
FAIL level 5 hpa | No CPU requests or no metrics yet | Set requests (level 4); wait a minute for metrics |
FAIL level 7 helm | The chart could not be pulled | Check internet access from the cluster and the chart version |
Error from server (Forbidden) | Your own account lacks cluster rights | On GKE, grant roles/container.developer or admin to your account |
Pods stay Pending | Not enough CPU or memory on the nodes | Lower requests or add a node |
What next
- GitOps for level 8: Argo CD on Kubernetes: GitOps from Zero.
- Observability for level 5: Prometheus and Grafana on Kubernetes from Scratch.
- More hands-on posts: ByteBlog. Practice in ByteLabs and see the courses.
Prepared by the CareerByteCode Team from our tested lab, with AI help for the write-up.
⭐ Keep learning with CareerByteCode
Hand-picked to go deeper on this topicGet CareerByteCode Team's next blog by email
One email a week when they publish. Add the weekly Best of ByteBlog too. No spam, unsubscribe with one click.
We email you once to confirm. By subscribing you agree to the privacy policy.
Related blogs
CareerByteCode TeamDevOps Engineer Roadmap 2027 with Hands-On Labs
What you build: a 2027 DevOps roadmap in 7 stages where every stage links to a tested lab, plus a real 15-minute lab that runs the whole loop: code, build, deploy, observe and roll back.
#ai
CareerByteCode TeamAI Engineer Roadmap: From Python to Production LLM Apps
What you build: a 7-stage AI engineer roadmap from Python to production LLM apps, with a real lab: a Gemini call, schema-checked JSON, a golden-set evaluation (6/6) and a temperature test.
#beginners
CareerByteCode TeamCloud Engineer Fresher Roadmap: 12 Labs in 12 Weeks
What you build: a 12-week cloud engineer plan for freshers with one tested lab every week, plus a real Week 0 readiness check that proves billing, a budget, a free VM and a bucket work.
#beginners
CareerByteCode TeamHow to Talk About Your Cloud Projects in Interviews
What you build: a STAR answer for cloud interviews from a real lab: a Cloud Run load test (0 failed, p95 64 ms), a broken release caught on its tag URL, and a script that uses only measured numbers.
💬 Comments (0)
Top · NewestSign in to comment