DevOps / SRE

Learn Bash: the shell every Linux server runs and most macOS terminals use. Variables, conditionals, loops, pipes, processes, scripts. Every lesson is hands-on — your code runs as a real bash script.

Level up from Bash Fundamentals. Arrays, parameter expansion, process substitution, traps, regex, robust scripting patterns. Write bash that doesn't fall over the moment input has a space in it.

Beyond Bash Intermediate. Traps, process substitution, named pipes, robust error handling, performance. The features that turn shell scripts into production tooling.

Learn Go: the language behind Docker, Kubernetes, and most of modern infrastructure. Static types, fast compiles, no class hierarchies. Every lesson is hands-on with real go run execution.

Level up from Go Fundamentals. Interfaces, error handling patterns, goroutines, channels, select, defer/panic/recover. The features that make Go unique — and how real Go services use them.

Beyond Go Intermediate. Context cancellation, sync primitives in depth, generics (1.18+), reflection, unsafe. The features Go services running at scale actually use.

Build a container runtime from scratch using Linux namespaces, cgroups, and overlayfs. You'll implement PID/mount/network namespace isolation, memory and CPU resource limits, layered image storage with copy-on-write, and the full container lifecycle. By the end you'll deeply understand what Docker, Podman, runc, and containerd actually do.

Build a CI/CD runner like GitHub Actions: parse YAML workflows, expand build matrices, topologically sort job DAGs, execute steps with logs, manage artifacts and caches, handle self-hosted runners, and protect secrets. Used by every modern engineering team.

Build a complete package manager from scratch — semver parsing, constraint matching, dependency tree expansion, deduplication, backtracking SAT-style resolution, lockfile generation, hash verification, lifecycle scripts, and vulnerability auditing. By the end you'll deeply understand what npm, yarn, pnpm, cargo, and pip actually do.

Build a fully-featured cron daemon from the ground up. You'll parse cron expressions, compute next firing times across timezones, schedule jobs with a min-heap, and handle real-world concerns like missed jobs, overlapping runs, and timezone DST. By the end you'll deeply understand the scheduler behind every "do this on a schedule" system you've ever used.

Build a production-grade L7 load balancer from scratch. You'll implement round-robin, weighted, and least-connection selection; active and passive health checks; circuit breakers; consistent hashing; sticky sessions; rate limiting; TLS termination (SNI); and Prometheus metrics. By the end you'll deeply understand what NGINX, HAProxy, Envoy, and AWS ALB actually do.

Build the registry behind Consul, Eureka, and Kubernetes service discovery: registration with TTLs, tags + metadata, health checks, load-balanced lookup, replicated HA, and the Kubernetes/service-mesh patterns. Used by every microservice architecture.

Build a Loki/Splunk-style log aggregator: ingest log lines via HTTP, structure them into label-keyed streams, store as compressed chunks, query by label + substring/regex (LogQL-style), aggregate over time, manage retention, and alert on thresholds. The observability stack every team eventually builds.