# ROOT_ V1 Syllabus

## Program description

ROOT_ is RootNode Academy's path from general computer literacy to operating and repairing real
infrastructure — Linux, Git, containers, and Kubernetes, taught through real hands-on Labs in a
disposable environment, culminating in a capstone that operates and recovers a production-like
system under realistic conditions.

## Intended audience / readiness

Approximately age 15 and up, through college students, adults, and career changers — including
help-desk technicians, junior sysadmins, developers, and anyone moving toward DevOps, cloud, or
platform engineering. Age is guidance, not a technical gate; readiness is what actually matters
(comfort with a keyboard and following multi-step instructions is the practical floor).

## Prerequisites

None external. ROOT_ does not require completing RootNode's INIT_ or COMPILE_ course families —
its own internal course sequence (below) is the only enforced prerequisite chain.

## Learning outcomes

By the end of ROOT_ V1, a student can: administer a Linux system and diagnose common failures;
use Git for real collaborative version control including merge conflicts; build, run, and
compose multi-container Docker applications; deploy, scale, and update workloads on a real
Kubernetes cluster; secure a cluster against common CKS-style findings; systematically
troubleshoot a broken system using a repeatable framework; and operate and recover a
production-like environment under a real incident.

## Course sequence

1. **Computing & Linux Foundations** — how a computer runs software, the shell, the filesystem,
   files/text, processes, permissions.
2. **Linux Administration & Networking** — service lifecycle, storage/filesystem administration,
   the networking mental model, network/DNS/HTTP diagnosis, structured troubleshooting.
3. **Git & Collaborative Development** — why version control exists, the Git mental model,
   everyday Git, branching and real merge conflicts, remote repositories, engineering workflow.
4. **Containers & Docker** — why containers exist, images vs. containers, the Docker CLI,
   container networking, container storage, Dockerfiles, Compose, and the bridge to Kubernetes.
5. **Kubernetes Foundations** — the Kubernetes mental model and core objects, Pods and kubectl.
6. **Kubernetes Application Workloads** — Deployments, scaling, rolling updates, Jobs/CronJobs.
7. **Kubernetes Networking & Configuration** — Services, service discovery, Ingress,
   NetworkPolicy, ConfigMaps/Secrets.
8. **Kubernetes Security** — SecurityContext, ServiceAccounts/RBAC, network and supply-chain
   security, cluster hardening — a formal CKS-style assessment, required before the Capstone.
9. **Kubernetes Troubleshooting & Observability** — health probes, the RootNode troubleshooting
   framework, general operational troubleshooting.
10. **RootNode Real Ops** — real, deliberately un-guided incident response.
11. **ROOT Capstone: Operate and Recover a Production-Like Environment** — a graded, timed,
    real-Lab final assessment combining every prior domain.

*(ROOT 08 — Kubernetes Storage & Scheduling — and the deeper modules of ROOT 11 — DevOps &
Platform Engineering — are not part of ROOT_ V1; see `docs/ROOT_V1_CURRICULUM_MANIFEST.md`. A
single ROOT 11 orientation module is included as optional bonus content.)*

## Assessments

Four course-ending assessments (ROOT 01, 02, 03, 04) validate foundational competency; one
(ROOT 09) validates security competency and is required before the Capstone. See
`docs/ROOT_V1_ASSESSMENT_MAP.md` for exact scope and duration of each.

## Capstone

A 90-minute, real-Lab, graded final assessment. Requires ROOT 12 (Real Ops) and ROOT 09
(Security) both complete, plus the pre-existing six-stage scenario gate (foundation, workloads,
networking, configuration, troubleshooting, real-ops). No new teaching — it tests what the
program already taught, under conditions closer to a real incident than a classroom exercise.

## Approximate structured hours

**64.2 hours** across the 12 V1 courses (excludes the deliberately-excluded ROOT 08). See
`docs/ROOT_PROGRAM_DURATION_MODEL.md` for the exact per-module breakdown this is built from.
This is instructional content time — it does not include instructor discussion, camp
activities, or self-paced review time, which vary by delivery format (see
`docs/ROOT_V1_INSTRUCTOR_LED_PILOT.md`).

## Tools & technologies

A real Linux shell, Git, Docker (via a safely nested Docker Engine inside each student's
disposable Lab, never touching the Lab host's own daemon), and a real single-node Kubernetes
cluster (k3s) — all provisioned automatically per student, with no local installation required.

## Learning expectations

Every module follows Learn → Practice → Lab → Troubleshoot → Validate (see `docs/
PHASE6F_ROOT_V1_PILOT_READINESS.md`'s orientation content for the full explanation given to
students). Labs validate themselves — a student always knows, immediately and objectively,
whether a task actually passed.