K8s Journey
An interactive Kubernetes course — zero to advanced — built with Next.js. Each lesson combines theory, prediction prompts, a scripted terminal walkthrough, a live cluster diagram, troubleshooting practice, active-recall quizzes, and spaced review.
~120 hours of content · 7 phases · no account needed
Learning Design
The course route is the learning method. Topics are ordered to reduce unnecessary cognitive load while gradually increasing real Kubernetes complexity:
- Mental model first — understand clusters, control plane behavior, kubectl, and kubeconfig before managing workloads.
- Core primitives next — learn Pods, Deployments, Services, and lifecycle behavior before adding reliability constraints.
- Reliability and configuration — add Namespaces, labels, ConfigMaps, Secrets, probes, and resource controls.
- Traffic and state — add storage, StatefulSets, DaemonSets, Ingress, and NetworkPolicies.
- Operations and safety — add RBAC, Jobs, autoscaling, scheduling, and disruption budgets.
- Production delivery — add Helm, Kustomize, CRDs, observability, GitOps, service mesh, and readiness checks.
- Timed performance — practice KCNA, CKA, and CKAD-style drills.
Every module follows the same evidence-backed loop:
- Preview — load the mental model and identify the objects involved.
- Predict — before each command, guess what API object, field, event, or status should change.
- Run the worked example — use the scripted lab and cluster diagram together.
- Explain — describe why the state changed in your own words.
- Troubleshoot — intentionally break one small thing and identify the failing object or field.
- Recall — answer quiz questions before revealing explanations.
- Transfer — repeat a similar task with a changed name, namespace, image, selector, or constraint.
- Space review — revisit the module after 1 day, 3 days, 7 days, and 21 days.
Every topic must also satisfy the course coverage contract:
- Concepts — what the Kubernetes object, subsystem, or tool is responsible for.
- Commands — exact commands the learner runs locally, usually with
kubectl, plus tool-specific CLIs when needed.
- Architecture — where the object fits in the control plane, node, network, storage, or delivery workflow.
- Techniques — operational patterns such as rollout, rollback, patching, scaling, canarying, debugging, isolation, or hardening.
- Procedures — ordered steps from a blank terminal to a verified outcome.
- Tools and plugins —
kubectl, Helm, Kustomize, ArgoCD, Istio, metrics-server, Prometheus/Grafana, etc. when relevant.
- Cases and scenarios — when the topic is used, when it fails, and how to recognize the failure.
- Local exercises — commands the learner can run on their own machine against a disposable cluster.
The app automatically audits each module against this contract and shows a verified or gap badge on the course overview. A module with a gap is not considered complete content.
The learning methods are intentionally conservative:
- Practice testing / retrieval practice: supported by Roediger & Karpicke and the Dunlosky et al. review.
- Distributed practice: supported as one of the highest-utility techniques in Dunlosky et al.
- Worked examples before independent solving: supported by cognitive load theory research for novice learners.
- Dual coding / multimedia learning: supported when visuals and words explain the same system and avoid decorative load.
- Interleaving / transfer practice: used after the learner has enough basics to compare related problem types.
If a claim is not known or verified, do not present it as fact. Kubernetes version-specific statements should be checked against the official Kubernetes release and documentation pages before being shown as current.
Course Structure
| Phase | Title | Duration |
|---|
| 0 | Mental Model Foundation | ~8h |
| 1 | Core Primitives | ~24h |
| 2 | Configuration & Reliability | ~9h |
| 3 | Storage, Ingress & Advanced Workloads | ~10h |
| 4 | Security, Scheduling & Reliability | ~10h |
| 5 | Advanced Kubernetes: Helm, CRDs & Observability | ~19h |
| 6 | Certification Prep (KCNA, CKA, CKAD) | ~40h |
Phase 0 — Mental Model Foundation
Why Kubernetes Exists · Cluster Architecture
Phase 1 — Core Primitives
Pods · Deployments · Services
Phase 2 — Configuration & Reliability
Namespaces · Labels & Selectors · ConfigMaps · Secrets · Health Probes · Resource Requests & Limits
Phase 3 — Storage, Ingress & Advanced Workloads
Volumes & PersistentVolumes · StatefulSets · DaemonSets · Ingress · NetworkPolicies
Phase 4 — Security, Scheduling & Reliability
RBAC · Jobs & CronJobs · Horizontal Pod Autoscaler · Taints, Tolerations & Node Affinity · PodDisruptionBudgets
Phase 5 — Advanced Kubernetes
Helm · Kustomize · Custom Resource Definitions · Observability (metrics-server, Prometheus, Grafana) · Production Readiness · GitOps · Service Mesh
Phase 6 — Certification Prep
KCNA · CKA · CKAD
How Each Lesson Works
- Learning Contract — objectives, retrieval targets, practice prompts, and mastery checks
- Read Theory — concept explanation with architecture diagrams
- Predict — state what should happen before each command
- Run the Lab — step-by-step scripted terminal walkthrough with real
kubectl output
- Watch the Diagram — live cluster diagram animates as you progress through steps
- Troubleshoot — break a small part and inspect the failed state
- Quiz — active recall questions with explanations
- Review Later — repeat recall and variant exercises on a spaced schedule
Tech Stack
- Next.js 15 (App Router) + React 19 + TypeScript
- Tailwind CSS for styling
- devenv (Nix) for reproducible dev environment
Getting Started
With devenv (recommended)
devenv shell # or: direnv allow (if you have direnv)
npm install
npm run dev
Without devenv
Requires Node 22+.
npm install
npm run dev
Open http://localhost:3000.
Project Layout
content/ # Course content (phase0.ts – phase6.ts)
phase0.ts # Each file exports a Phase with modules, lab steps, and quizzes
learningDesign.ts # Evidence-based learning loop, defaults, and phase roles
...
app/
page.tsx # Landing page
learn/ # /learn route — phase/module browser
[phase]/[module]/page.tsx
components/
ClusterDiagram.tsx # Animated live cluster diagram
ScriptedTerminal.tsx # Step-through terminal walkthrough
QuizCard.tsx # Active recall quiz
Sidebar.tsx # Navigation
lib/
types.ts # Core types: Phase, Module, LabStep, QuizQuestion, ClusterState
progress.ts # Progress tracking
Adding Content
Each phase file (content/phaseN.ts) exports a Phase object. To add a module, append to the modules array following the Module type in lib/types.ts:
{
id: 'pN-mX',
slug: 'my-topic',
title: 'My Topic',
description: '...',
duration: '30 min',
difficulty: 'intermediate',
learningObjectives: ['...'],
keyConcepts: ['...'],
practicePrompts: ['...'],
masteryChecks: ['...'],
theory: `## Markdown theory content`,
labSteps: [ /* LabStep[] */ ],
quiz: [ /* QuizQuestion[] */ ],
}
The learning metadata is optional. If it is missing, the app generates conservative defaults from the module title and lab steps so existing topics remain available.
Evidence References
- Dunlosky, J., Rawson, K. A., Marsh, E. J., Nathan, M. J., & Willingham, D. T. (2013). Improving Students' Learning With Effective Learning Techniques.
- Roediger, H. L., & Karpicke, J. D. (2006). Test-Enhanced Learning: Taking Memory Tests Improves Long-Term Retention.
- Mayer, R. E. (2008). Applying the Science of Learning: Evidence-Based Principles for the Design of Multimedia Instruction.
- Sweller, J., van Merrienboer, J. J. G., & Paas, F. (1998). Cognitive load theory and instructional design research.
- Renkl, A., Atkinson, R. K., & Maier, U. H. (2000s). Worked-example fading and cognitive load research.
- Kubernetes official documentation: https://kubernetes.io/docs/
- Kubernetes official releases: https://kubernetes.io/releases/
- Kubernetes kubectl reference: https://kubernetes.io/docs/reference/kubectl/
- Helm command reference: https://helm.sh/docs/helm/
Scripts
npm run dev # Start dev server
npm run build # Production build
npm run start # Start production server
npm run lint # ESLint