Where to Go Next

If you're going for the CKA

This course covers the large majority of the CKA curriculum hands-on: cluster architecture, workloads & scheduling, services & networking, storage, and troubleshooting are all directly exercised in a lab. A few exam-specific things worth doing before you sit it:

• Check the current exam syllabus and version on the Linux Foundation's CKA page — the exact Kubernetes version and weightings get updated periodically.
• Practice fast, bare `kubectl` without autocomplete assumptions — the real exam environment is a plain terminal; get comfortable with `kubectl explain`, `--dry-run=client -o yaml`, and imperative commands as scaffolding for YAML you then edit.
• Time yourself. The exam is tightly timed across ~15-20 tasks — this course's mock exam is good practice for that pressure, but run it more than once and aim to beat your own time.
• Get fast at `kubectl config set-context --current --namespace=` and bookmarking which cluster/context you're in — a surprising number of exam point losses are “did the right thing, wrong cluster.”

Taking the EKS side further

Module 15 was deliberately conceptual — no AWS account required. The natural next step is standing up a real (small, cheap) EKS cluster and redoing a few labs against it for real:

• Provision one with `eksctl` or a minimal Terraform module — either teaches you the real control-plane/node-group split this course only described.
• Install the AWS Load Balancer Controller and actually provision an ALB from an Ingress — compare its annotations to what you saw in lab-32.
• Set up IRSA or Pod Identity for real and watch a pod assume an actual IAM role, not just a correctly-shaped ServiceAccount annotation.
• Turn on Karpenter and watch it provision/consolidate nodes under real load — the single biggest operational difference from this course's fixed 3-node kind cluster.
• Tear it down when you're done. An idle EKS control plane alone is about $73/month — this is exactly the kind of cost-awareness Module 15 flagged.

Deepen specific areas

• GitOps: Argo CD or Flux — applying what you learned about Helm/Kustomize (Module 12) as a continuously-reconciled pipeline instead of manual applies.
• Observability beyond kubectl: Prometheus + Grafana for metrics, Loki or the EFK stack for logs — Module 13 taught the manual version of what these automate.
• Service mesh: Istio or Linkerd, once you're comfortable with NetworkPolicy (Module 11) and want mTLS, retries, and traffic shifting as platform features rather than app code.
• Multi-cluster & fleet management: once one cluster feels routine, tools like Cluster API or Karmada address running many.

Keep this cluster around

Your local kind cluster (`scripts/cluster-up.sh`) is a genuinely useful thing to keep: test a manifest before committing it, try a new CRD without touching a shared cluster, or reproduce a production bug in isolation. The habits this course built — check `kubectl describe` and Events first, question desired-vs-actual state, verify a fix against a real cluster instead of trusting a YAML diff — are the actual skill. The specific commands will keep evolving; that diagnostic instinct won't.