← Back to the School portal

🎓 The Program — the whole School as one curriculum

Everything the nine schools teach, laid out like a course prospectus: what you'll learn, in what order, how long it takes, and what you can do afterwards. The difference from a paid bootcamp: every number below is real, and the fee is zero — forever.

9courses
107lessons
~70 hreading + labs
115+diagrams
4runnable codebases
$0forever · MIT
📚 See the full curriculum 🏫 Back to the portal 🖨️ Print this prospectus

🧭 How the program works

🧒 One method, everywhere

Every concept is a school-analogy story first (pods are desks, IAM roles are hats, RAG is an open-book exam) — then the real thing, with the jargon attached to a picture you already understand.

🌿 One git branch = one lesson

Branches are cumulative: check out lesson 07 and lessons 1–7 are all there. You learn git by simply taking the course.

📐 Numbered diagrams

Every lesson is one box-and-arrow diagram with circled numbers — follow 1 → 2 → 3 and you've read the architecture. Big-picture 4K posters per course.

🧪 Proof over promises

Four repos ship real, zero-dependency code: a tiny language model, an MCP server and client, an AI agent, a vector database. Quizzes and browser-saved study plans in every course.

🗺️ Choose your path

☁️ The Ops track — ~23 weeks part-time

  • AWS (6 weeks) — identity, computers, and the campus
  • Docker & ECR (4 weeks) — pack it, ship it
  • Kubernetes (9 weeks) — the flagship: run it
  • ArgoCD (4 weeks) — deploy it from git, forever

🧠 The AI track — ~13 weeks part-time

  • AI (4 weeks) — how models actually work
  • Vector Databases (3 weeks) — the meaning hall
  • MCP (3 weeks) — the universal plug
  • AI Agents (3 weeks) — the capstone loop

"Part-time" assumes 2–4 sessions a week of ~40 minutes. Both tracks at once ≈ 9 months; one track sprinted full-time ≈ 5–7 weeks. Every course has its own weekly plan with checkboxes that survive in your browser.

📚 The curriculum — nine modules

Click a module to expand it. Hours are honest estimates: reading + doing the labs.

🪪 Module 1 — AWS: IAM, EC2 & the campus 20 lessons · 6 weeks · ~13 h
Part 1 — identity: the root master key, users & groups, policy slips, roles-as-hats, machine identities, hygiene. Part 2 — computers: instances, types & pricing, connecting (SSH vs SSM), security groups, EBS/snapshots/AMIs, user-data & fleets. Part 3 — the campus: VPC, S3, load balancers, Route 53, RDS, CloudWatch, Lambda, and reading the bill. Labs in Terraform + CLI, ~1¢/hour, always destroyed.
Course site → 6-week plan Quiz (12 Qs)
🍱 Module 2 — Docker & ECR 12 lessons · 4 weeks · ~7.5 h
Why containers, images & layers, the Dockerfile, running containers, volumes & networks, Compose, multi-stage builds, image hygiene (.dockerignore, tags vs digests), registries, ECR, lifecycle policies, CI to the cloud. Includes a real demo app and a working multi-stage build that shrinks 180 MB to 50 MB.
Course site → 4-week plan Quiz
☸️ Module 3 — Kubernetes (the flagship) 26 lessons · 9 weeks · ~17 h
The core (1–13): pods, Deployments, Services, namespaces, config & secrets, probes, resources, HPA, ingress, rollouts, storage, the control plane. Ship it (14–15): GitOps and multi-AZ. Run it for real (16–26): debugging (CrashLoopBackOff and friends), RBAC, Jobs & CronJobs with a real backup, NetworkPolicies, taints, DaemonSets, StatefulSets, QoS & evictions, node upgrades, CRDs & operators, observability. Real manifests for a real platform, plus the AWS-components map.
Course site → 9-week plan Quiz (10 Qs)
🤖 Module 4 — ArgoCD & GitOps 12 lessons · 4 weeks · ~7.5 h
Deployment before GitOps, drift, push vs pull, the plan-book idea, ArgoCD's architecture, Applications, sync policies, selfHeal & prune, instant rollbacks with git revert, app-of-apps, secrets in GitOps (Sealed Secrets & ESO). Ships a deployable demo app you can point a real ArgoCD at.
Course site → 4-week plan Quiz
🧠 Module 5 — AI: tokens to agents 13 lessons · 4 weeks · ~8 h
What ML actually is, training & loss, tokens & BPE, embeddings, next-token prediction, attention & transformers, pretraining → RLHF → LoRA, prompting & context windows, hallucinations, RAG, agents, diffusion & multimodal, MCP. Three runnable zero-dependency Python labs: a bigram language model, a tokenizer, an attention toy.
Course site → 4-week plan Quiz (10 Qs)
🗺️ Module 6 — Vector Databases 8 lessons · 3 weeks · ~5 h
Search by meaning, embeddings as coordinates, cosine similarity & normalization, kNN vs ANN (HNSW, IVF, recall), building a mini vector DB, chunking & metadata filters & hybrid search, rerankers, the landscape (pgvector to dedicated engines). A real ~70-line vector database lives in the repo — including one honest failure that teaches more than success.
Course site → 3-week plan Quiz
🔌 Module 7 — MCP: the universal plug 8 lessons · 3 weeks · ~5 h
The N×M problem, hosts/clients/servers, tools vs resources vs prompts, the JSON-RPC wire message-by-message, transports & security (prompt injection, write gates), then five real use cases with sequence diagrams. The protocol is IN the repo: a working server and client (~200 lines, stdlib only) you can drive by hand.
Course site → 3-week plan Quiz
📋 Module 8 — AI Agents (the capstone) 8 lessons · 3 weeks · ~5 h
Answers vs outcomes, the think→act→observe loop, tools as the agent's hands, memory & compaction, guardrails (step budgets, write gates), failure modes & evals, multi-agent patterns, and when NOT to build an agent. Ships a runnable agent you can drive yourself — plus the history-and-future page: what came before agents and what "agentic" means.
Course site → 3-week plan Quiz (10 Qs)
🔗 Module 0 — the short link 1 redirect · 10 seconds · the smallest school
baluraut.github.io/k8s → the Kubernetes course. Share the short one. That's the whole module. 😄

🛠️ Tools & technologies you'll touch

KubernetesDockerAWS EC2 IAMVPCS3 ALBRoute 53RDS CloudWatchLambdaECR ArgoCDTerraformGitHub Actions gitPythonJSON-RPC / MCP vector searchSSMHelm-free YAML 😄

🎒 Who this is for

✅ A great fit if you…

  • are a developer/tester/student who wants DevOps or AI fundamentals that stick
  • learn best from pictures and stories, not walls of jargon
  • want to RUN things, not just read about them
  • have a laptop with a terminal and ~3 hours a week

🎓 Prerequisites (honestly few)

  • basic terminal comfort (cd, ls — we teach the rest)
  • no CS degree, no math beyond arithmetic
  • an AWS account only for some labs (~1¢/hour, always destroyed; a $5 budget tripwire is lesson one of cost hygiene)

💼 What you'll be able to do afterwards

The skills below map to what job listings call DevOps engineer, platform engineer, cloud engineer, AI engineer, and solutions architect — we teach the skills; we make no placement promises (nobody honestly can).

After the Ops track

  • read any AWS architecture diagram and know every box
  • containerize an app and ship it to a registry with CI
  • deploy, debug, scale and upgrade workloads on Kubernetes
  • run deployments from git with drift-free GitOps
  • find the four classic money leaks in a cloud bill

After the AI track

  • explain tokens → attention → RLHF without hand-waving
  • design a RAG pipeline and know when it will fail
  • wire a model to real tools over MCP — you've read the wire
  • build (and know when NOT to build) an AI agent with guardrails

📜 Certification

🎓 The School Certificate of Completion

Finish all eight schools on the grand path and the portal unlocks a printable certificate with your name and completion date. It certifies something rarer than attendance: zero magic left — every claim on it is backed by a diagram you can redraw and code you can run. It's self-issued and free, like everything here; the real credential is the 107 lessons in your git history.

❓ FAQ

Is it really free? What's the catch?
Really free, MIT licensed, no sign-up, no email capture, no upsell. The only costs are optional AWS lab pennies (with a $5 tripwire taught in lesson one of cost hygiene). The catch: nobody chases you — the study plans' checkboxes are your only accountability. 😄
What order should I take the courses in?
Ops track in order (AWS → Docker → Kubernetes → ArgoCD) — each stands on the previous. AI track in order (AI → VectorDB → MCP → Agents). The two tracks are independent; interleave freely. Total beginner? Start with Docker's lesson 01 — it's the gentlest door.
How long does the whole program take?
~36 weeks at 2–4 short sessions a week; one track ≈ 13–23 weeks; a focused full-time sprint through one track ≈ 5–7 weeks. There are no deadlines and no batches — the branches wait for you.
Do I need to install anything?
git + a terminal always; Docker Desktop for the Docker/k8s labs; Python 3 (stdlib only — never pip install) for the AI-side repos; Terraform + an AWS account for the AWS labs. Every lesson says exactly what it needs.
Found a mistake — what do I do?
Every page's footer has a 🐛 link to that course's GitHub issues. Corrections are the school's favorite kind of homework.
🤝 The honesty box: this program is a solo-built, open-source study resource — not an accredited institution. There are no instructors on call, no rankings, no placement statistics, and no reviews score. What there IS: every lesson public, every diagram inspectable, every line of code runnable, and a git history that can't lie about any of it.