CareerByteCode
ByteBlogby CareerByteCode

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).

Kubernetes Roadmap: From Pods to Platform Engineering

✍️ 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

Kubernetes roadmap
Eight levels in four stages: run apps, configure them, scale and secure them, then package and automate them as a platform
LevelYou learnThe check
1. Podscontainers, kubectl run, logs, describea pod reaches Ready
2. Deployments and Servicesreplicas, rollouts, stable names2 replicas answer through a Service
3. ConfigurationConfigMaps, Secrets, env and filesthe app reads a ConfigMap value and a Secret
4. Health and resourcesprobes, requests and limits, zero-downtime rolloutsa readiness probe and requests roll out cleanly
5. Scalingmetrics, HorizontalPodAutoscaleran HPA manages the deployment (2 to 5 pods)
6. SecurityRBAC, service accounts, least privilegea viewer account may list pods but not delete them
7. PackagingHelm charts, values, releasesa Helm release is deployed
8. Everything as code (platform)YAML in Git, GitOps, policies, golden pathsthe 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

  1. A Google Cloud account with billing and a project. This lab uses a small GKE cluster (not free).
  2. Open Cloud Shell (the >_ icon at the top right of the console); it has kubectl and helm. 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
  1. Save the level check as levels.sh in a folder ~/lab320 (mkdir -p ~/lab320 && cd ~/lab320, then nano 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 $FAILED

Step 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.2377000

Step 2: run the level check

# Run the level check: one real task per roadmap level
cd ~/lab320
chmod +x levels.sh && time ./levels.sh
PASS  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
Level check
All eight levels PASS: pod, deployment and service, config, probes, HPA, RBAC, Helm, and state as code

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$" | sort
configmap/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/viewer

Deployments, 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.

Objects and clean up
Everything the eight levels created, from a ConfigMap to a RoleBinding, and the namespace deleted at the end

Part C: the study plan, level by level

LevelWeeksStudy with
1-23the Kubernetes basics docs, then our CKAD Practice: 20 Developer Tasks on a Real Cluster, tasks 1 to 4
3-43ConfigMaps, Secrets, probes and resources (CKAD practice tasks 5 to 8)
52metrics and autoscaling: Prometheus and Grafana on Kubernetes
62RBAC and identity, plus cloud IAM: Google Cloud IAM for Beginners
72Helm: write a chart, test it, publish it
84GitOps and a service mesh: Argo CD on Kubernetes, Istio for Beginners
BeyondongoingAI 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

  1. 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.)
  2. kubectl auth can-i delete pods --as=... says no. Which level does that prove? (Answer: level 6, RBAC and least privilege.)
  3. What does platform engineering add on top of level 8? (Answer: self-service templates, GitOps, policies and observability so other teams can ship safely.)
  4. Your HPA check fails. What do you check first? (Answer: that the deployment has CPU requests (level 4) and that metrics are available.)
  5. 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.yaml
namespace "roadmap" deleted

Then delete the cluster when you finish:

gcloud container clusters delete lab-cluster --zone=us-east1-b --quiet

FAQ

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 seeWhyFix
FAIL level 2 serviceThe Service had no ready endpoints yetWait a few seconds and retry; check kubectl get endpoints
FAIL level 5 hpaNo CPU requests or no metrics yetSet requests (level 4); wait a minute for metrics
FAIL level 7 helmThe chart could not be pulledCheck internet access from the cluster and the chart version
Error from server (Forbidden)Your own account lacks cluster rightsOn GKE, grant roles/container.developer or admin to your account
Pods stay PendingNot enough CPU or memory on the nodesLower requests or add a node

What next

Prepared by the CareerByteCode Team from our tested lab, with AI help for the write-up.

Read next →DevOps Engineer Roadmap 2027 with Hands-On Labs⏱ 9 min

⭐ Keep learning with CareerByteCode

Hand-picked to go deeper on this topic
News, guides and updates from the CareerByteCode team
🏅 Expert writer

The CareerByteCode team writes about what is new on careerbytecode.in: courses, labs, exams, events and the community, which is free to join for influencers and content creators in tech.

Get 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.

💬 Comments (0)

Top · Newest

Sign in to comment

Related blogs

🎓⭐ Recommended by CareerByteCode · Live trainingAWS Cloud Architecture and AIOps Bootcampโ‚น10,620See the training →