Skip to content

DevOps Foundations

Foundations · prereq 00 (Setup & AI-native ways of working) · ~half a day

This is the map every later module hangs on. First: why DevOps exists (the CALMS model). Then the VM → container → Kubernetes → cloud progression — the same ladder every tool module in this course climbs one rung further.

TL;DR — in 30 seconds:

  • DevOps exists to close the gap between Dev (wants change) and Ops (wants stability) — CALMS (Culture, Automation, Lean, Measurement, Sharing) is the model for closing it.
  • Infrastructure climbs one ladder: VM → container → Kubernetes → cloud — each rung automates away a problem the rung below couldn't solve.
  • Every later tool (Podman, Kubernetes, Terraform, Ansible, RHEL) is just something that lives on that ladder — this module is the map, not the tool.

Learning objectives

By the end, the junior can:

  • Explain what DevOps is and why it exists using the CALMS model (Culture, Automation, Lean, Measurement, Sharing) — in their own words.
  • Trace the VM → container → Kubernetes → cloud progression and say what problem each step solves.
  • Place the team's stack (Podman, Kubernetes, Helm, Terraform, Ansible, RHEL) onto that map and justify where each sits.
flowchart LR
    VM["VM<br/>(full OS per app;<br/>deps drift between hosts)"]
    C["Container<br/>(deps baked into the image)"]
    K["Kubernetes<br/>(cluster-scale automation)"]
    Cloud["Cloud<br/>(IaaS/PaaS/FaaS/SaaS)"]

    VM -->|"embed deps in the image<br/>instead of the host"| C
    C -->|"automate restart, scaling,<br/>and cross-host networking"| K
    K -->|"stop self-hosting every<br/>supporting service"| Cloud

Every module runs the same five-beat loop, gated on Prove — defend your work and you move on; hand-wave it and you loop back to Pair:

graph LR
    L[Learn] --> P[Pair]
    P --> D[Do]
    D --> V{"Prove — defend it"}
    V -- pass --> R[Retain]
    V -- fail --> P

Objectives set, loop understood — time to meet CALMS and the progression for real, starting with the deck.

Do it with Claude

Pair, Do and Prove run in Claude Code, with the onboarding-tutor skill. Click a button to copy the exact prompt, then paste it into Claude Code in this repo.

1. Learn · acquire the concept

Read the deck in order — under the DevOps Foundations deck: origins.md → principles.md → vm.md → containers.md → kubernetes.md → cloud.md

Focus: principles.md (CALMS) and the why of each step in vm → containers → kubernetes. Skip for now: Vagrant specifics, provider-by-provider cloud catalogues — you'll meet the real tools in later modules.

Check yourself — name the five CALMS letters and one line on each

Culture (dev and ops share ownership of the outcome, not just their half) · Automation (repeatable pipelines instead of manual steps) · Lean (small batches, fast feedback) · Measurement (decisions driven by data, not opinion) · Sharing (knowledge and tooling aren't siloed between teams).

Check yourself — what's the 'wall of confusion', and which CALMS letter attacks it directly?

The wall of confusion is the friction that builds up when Dev (optimizing for change) and Ops (optimizing for stability) work in separate silos with conflicting incentives. Culture attacks it directly — shared ownership removes the incentive to throw problems over the wall.

2. Pair · passive → active

Work the deck with the onboarding-tutor skill. Prompts:

  • "Explain CALMS and give me one concrete SE example of each letter."
  • "Give me a 3-line mental model of why containers replaced VMs for most workloads."
  • "Quiz me on the VM → container → k8s → cloud progression before I do the exercise."

Done when: you can say, unprompted, why DevOps exists and what each step of the progression buys you.

3. Do · produce an artifact

Exercise — the DevOps map (written deliverable): Create devops-map.md in your scratch space containing:

  1. A one-paragraph definition of DevOps framed by CALMS.
  2. A simple diagram or list placing VM → container → Kubernetes → cloud with one sentence per step: what problem it solves.
  3. The team's stack (Podman, Kubernetes, Helm, Terraform, Ansible, RHEL, mise) placed onto that map, each with a one-line justification of where it sits and why.

  4. Three "why" statements in your own words: why DevOps, why containers over VMs, why orchestration over lone containers.

  5. The tutor coaches but does not write it for you.

Done when: devops-map.md exists and covers all four parts.

Common gotchas

  • Reciting CALMS as an acronym instead of explaining it. Fix: for each letter, be ready to say why it exists and give one concrete example — the gate tests the reasoning, not the mnemonic.
  • Treating "container" and "VM" as interchangeable. Fix: the difference is where dependencies live — baked into the image (container) vs. installed on the host (VM) — not just "smaller VM."
  • Assuming Kubernetes replaces containers. Fix: Kubernetes orchestrates containers (restart, scale, network them across hosts) — you still build and ship the same images.
  • Placing a tool on the map by familiarity instead of by function. Fix: ask what problem the tool solves (packaging? orchestration? provisioning?), then find that rung on the ladder.
  • Treating the deck's Vagrant/cloud-catalogue detail as required reading. Fix: it's flagged "skip for now" — spend your time on principles.md and the why of each ladder step instead.
Check yourself — why did containers replace VMs for most workloads?

Because containers embed dependencies in the image instead of on the host — that kills "works on my machine" drift and needs far less overhead per app than a full guest OS.

Check yourself — what does Kubernetes add on top of containers that a single Podman host can't give you?

Cluster-scale automation: restart on failure, scaling based on demand, and networking/service discovery across hosts — not just on one machine.

4. Prove · understanding gate

Mandatory. Pass bar in the Socratic gate.

  1. Walkthrough: Talk me through your map. Why did you place Helm and Terraform where you did?
  2. Alternative: When is a VM still the right answer over a container? Give a real case.
  3. Failure & debug: A teammate says "just put it all in one big container." What goes wrong, and which CALMS principle does that violate?
  4. Provenance: Which parts of your map did you get from an AI, and how did you check them against the deck?

Pass bar: you can defend every placement and the three "why"s. Hand-waving the progression = back to Pair.

5. Retain · fight forgetting

Study the module deck SE Onboarding::01 DevOps Foundations — its 6 theme subdecks (Origins · CALMS · Measurement/observability/IaC · Virtualization & cloud · Containers · Orchestration/Kubernetes) let you drill one area at a time. It auto-syncs to your Anki on git pull (anki-sync) — nothing to import by hand.

Done when: you can recall — from the deck — the CALMS pillars, why the DEV/OPS split creates the "wall of confusion", the VM → container → Kubernetes progression, and why containers over VMs.

Key takeaways

  • DevOps closes the gap between Dev (wants change) and Ops (wants stability) — CALMS (Culture, Automation, Lean, Measurement, Sharing) is the model for closing it.
  • The "wall of confusion" is what builds up when Dev and Ops work in separate silos with conflicting incentives — Culture attacks it directly by putting shared ownership on both sides.
  • Infrastructure climbs one ladder: VM → container → Kubernetes → cloud — each rung automates away a problem the rung below couldn't solve.
  • Containers replaced VMs because dependencies live in the image, not the host — that kills "works on my machine" drift and needs far less overhead per app than a full guest OS.
  • Kubernetes adds cluster-scale automation on top of containers — restart on failure, scaling, and cross-host networking/service discovery — it doesn't replace containers, it orchestrates them.
  • Place a tool on the map by the problem it solves (packaging? orchestration? provisioning?), not by familiarity — that's how Podman, Kubernetes, Helm, Terraform, Ansible, and RHEL each find their rung.

Go deeper — curated resources

Hand-picked external material to take this topic further — the best books, courses, talks, and writing. Cost is tagged Free, Free online (full text/course free on the web), or Paid.

  • Book · The Phoenix Project — Gene Kim, Kevin Behr & George Spafford (IT Revolution). The business novel that makes DevOps click. Paid.
  • Book · The DevOps Handbook — Kim, Humble, Debois & Willis (IT Revolution). The concrete practices behind the story. Paid.
  • Book · Accelerate — Forsgren, Humble & Kim (IT Revolution). The research on what high performers actually do. Paid.
  • Book · Google SRE Book — Google. How Google runs production — the full text, free. Free online.
  • Talk · 10+ Deploys per Day: Dev and Ops Cooperation at Flickr — John Allspaw & Paul Hammond (Velocity 2009). The talk that lit the fuse for DevOps. Free.
  • Blog · Dev Ops Culture — Rouan Wilsenach, martinfowler.com. Why DevOps is culture first, tools second. Free.

Gate log (mentor fills on pass)

  • Date passed:
  • Passed by: / checked by:
  • Weak spots noticed (feeds system improvement):