Everything the rest of the course assumes, from a standing start.

• Linux anatomy, boot process, filesystem hierarchy and the /proc interface
• File and directory management, links, archiving, compression
• Text processing: vim, grep, sed, awk, cut, sort, uniq, tr
• Users, groups, sudoers, file permissions, SUID/SGID, umask, ACLs
• Process management: ps, top, htop, kill, signals, nice, systemd units
• Package management with apt, yum and dnf
• Disk and storage: df, du, mount, LVM, swap
• Networking for DevOps: ip, netstat, ss, dig, nslookup, curl, traceroute, tcpdump
• Shell scripting: variables, conditionals, loops, functions, arguments, exit codes
• Cron, at and systemd timers for scheduled work
• Log analysis with journalctl and tail, and writing a log-parsing script

The cloud services a DevOps engineer touches daily - not a certification tour.

• Account structure, regions, availability zones and the shared responsibility model
• Virtual networking: VPC/VNet, subnets, route tables, gateways, peering
• Network security: security groups, NACLs, network security groups, bastion patterns
• Compute: instance families, sizing, spot and reserved pricing, autoscaling groups
• Identity and access: users, roles, policies, least privilege, instance profiles
• Object storage: buckets, lifecycle policies, versioning, encryption, static hosting
• Managed databases: provisioning, backups, read replicas, failover
• Messaging and queuing between services
• Load balancing: layer 4 versus layer 7, target groups, health checks
• Monitoring and audit logging, and alarms on the metrics that matter
• Managed container services and when to reach for them
• Cost control: tagging, budgets, rightsizing, and where cloud bills actually go

Version control as it is used on a team, then your first real pipeline.

• Git internals: objects, refs, the index, and what a commit really is
• Branching, merging, rebasing, cherry-picking and when each is appropriate
• Resolving conflicts without fear; reflog and recovering lost work
• Trunk-based development versus GitFlow, and why teams choose each
• Pull requests, code review, protected branches and required checks
• Tags, releases and semantic versioning
• GitHub Actions: workflows, jobs, steps, runners and the event model
• Matrix builds, caching, artifacts and reusable workflows
• Secrets, environments and manual approval gates
• Building a CI pipeline: lint, test, build, scan, publish

Making servers reproducible instead of hand-tuned.

• Push versus pull configuration management, and where Ansible fits
• Inventory: static, dynamic, groups, host and group variables
• Ad-hoc commands and the most useful modules
• Playbooks: tasks, handlers, conditionals, loops, blocks
• Variables, facts, registers, templates with Jinja2
• Roles, role dependencies and directory structure
• Ansible Vault for secrets
• Idempotence, check mode and diff
• Ansible Galaxy, collections and the wider ecosystem
• Applying a full server build end to end

The tool most job descriptions ask for, taught to production standard.

• Infrastructure as code principles and declarative versus imperative
• HCL syntax, expressions and the Terraform lifecycle: init, plan, apply, destroy
• Providers, resources, data sources and resource addressing
• Variables, locals, outputs, type constraints and validation
• Built-in functions: string, collection, encoding and filesystem
• Meta-arguments: count, for_each, depends_on, lifecycle
• Dynamic blocks and conditional expressions
• State: local versus remote, S3/Azure backends, locking, drift
• State surgery: import, move, taint, replace - and when not to
• Modules: writing, versioning, composing and publishing
• Workspaces and structuring multi-environment projects
• Testing and validation: fmt, validate, tflint, checkov
• Packer for building golden machine images

Containers from first principles, not just docker run.

• Namespaces, cgroups and what a container actually is
• Images, layers, the union filesystem and the build cache
• Writing Dockerfiles: instructions, context, .dockerignore
• Multi-stage builds and getting images genuinely small
• Non-root containers, distroless bases and image hardening
• Volumes, bind mounts and data persistence
• Container networking: bridge, host, overlay, port publishing
• Registries: tagging strategy, pushing, pulling, private registries
• Docker Compose for local multi-service development
• Debugging a container that will not start

Two full weeks - the longest block, because this is what interviews dig into.

• Architecture: API server, etcd, scheduler, controller manager, kubelet, kube-proxy
• Pods, ReplicaSets, Deployments, StatefulSets, DaemonSets, Jobs and CronJobs
• Services, Endpoints, and ClusterIP versus NodePort versus LoadBalancer
• Ingress, and the Gateway API that is replacing it
• ConfigMaps, Secrets and the twelve-factor config pattern
• Storage: volumes, PersistentVolumes, claims, storage classes
• Namespaces, labels, selectors, annotations
• Resource requests and limits, QoS classes, LimitRanges, ResourceQuotas
• Scheduling: node selectors, affinity and anti-affinity, taints, tolerations
• Probes: liveness, readiness, startup - and the outages caused by getting them wrong
• RBAC: roles, bindings, service accounts, least privilege
• Autoscaling: HPA, VPA, Cluster Autoscaler and Karpenter
• EKS / AKS specifics: cluster provisioning, node groups, the CNI, IAM integration
• Helm: charts, templates, values, releases, rollbacks, chart dependencies
• Kustomize: bases, overlays, patches, and Helm versus Kustomize
• Service mesh with Istio: sidecars, mTLS, traffic shifting, retries, circuit breaking
• Cilium and eBPF networking, and network policy
• Cluster upgrades and node draining with zero downtime
• Debugging: CrashLoopBackOff, ImagePullBackOff, Pending pods, OOMKilled

Knowing something is broken before a customer tells you.

• Metrics, logs and traces - the three pillars and what each is for
• Prometheus: data model, exporters, scrape configs, service discovery
• PromQL: selectors, rate, aggregation, recording rules
• Alertmanager: routing, grouping, inhibition, silences, on-call escalation
• Grafana: dashboards, variables, panels, alerting
• ELK stack: Elasticsearch indices, Logstash pipelines, Kibana queries
• Fluent Bit and Fluentd for log shipping from Kubernetes
• OpenTelemetry: instrumentation, collectors, distributed tracing
• New Relic for APM
• SRE practice: SLI, SLO, error budgets, and alerting on symptoms not causes

Git as the single source of truth for what is running.

• GitOps principles and how they differ from push-based deployment
• Installing and configuring ArgoCD on EKS / AKS
• Applications, projects, sync policies, automated sync and self-healing
• App of Apps and managing many applications at scale
• Repository structure for GitOps and separating config from code
• Secrets in GitOps: sealed secrets and external secret operators
• Progressive delivery: blue-green, canary and traffic shifting
• Argo Rollouts and automated rollback on metric regression
• Drift detection, diffing and reconciliation
• Designing a promotion path from dev to staging to production

Shifting security left, which is the part most courses skip.

• Threat modelling a delivery pipeline
• SonarQube: quality gates, coverage, technical debt, PR decoration
• SAST, DAST and where each belongs in a pipeline
• Dependency and container scanning with Trivy
• Host auditing and hardening with Lynis and CIS benchmarks
• HashiCorp Vault: secret engines, dynamic secrets, leases, Kubernetes auth
• Secret rotation and getting credentials out of source control
• Policy as Code: OPA, Rego and Gatekeeper admission control
• Supply chain security: SBOM generation, Cosign image signing, SLSA levels
• Kubernetes security: pod security standards, network policy, admission control
• Building a pipeline that fails on a real vulnerability

Enough Python to automate the things no tool covers.

• Syntax, data types, control flow and functions
• Data structures: lists, dicts, sets, tuples and comprehensions
• Strings, formatting and regular expressions
• File and JSON/YAML handling
• Error handling, logging and writing scripts that fail loudly
• The os, sys, subprocess, shutil and pathlib modules
• psutil for system metrics, paramiko for remote execution
• requests for REST APIs and pagination
• Boto3 and cloud SDK automation
• Virtual environments, pip, requirements and packaging a CLI
• Serverless functions in Python
• Writing a real automation: an audit script you keep

The part that is genuinely new, and increasingly asked about in interviews.

• GitHub Copilot for infrastructure as code and pipeline authoring
• Prompt engineering for automation and code generation
• AI-assisted code review and pull request summarisation
• AIOps: anomaly detection on metrics and predictive alerting
• Log clustering and noise reduction at scale
• ChatOps: incident response driven from chat
• Running LLM infrastructure on Kubernetes: GPU scheduling, model serving
• MLOps fundamentals: model registries, pipelines, drift monitoring
• Where AI genuinely helps in operations and where it does not

You build the thing you will talk about in every interview.

• End-to-end microservices deployment on AWS / Azure, built by you
• Terraform-provisioned infrastructure, reviewed line by line
• Containerised services with hardened images
• Deployment on EKS / AKS with Helm and autoscaling
• ArgoCD GitOps delivery with a full promotion path
• Security gates: Trivy, SonarQube, Vault, OPA in the pipeline
• Prometheus and Grafana observability with meaningful alerts
• Ten production troubleshooting scenarios, worked end to end
• Scenario-based mock interviews with direct feedback
• Resume and ATS review against real job descriptions
• Certification roadmap: AWS SAA-C03, CKA and Terraform Associate
• How to present the project so an interviewer understands it in five minutes