Skip to content

Training Dependency Graph

A prerequisite map for all training content. Use this to sequence your learning and avoid hitting advanced material before the foundations are solid.

Reading This Graph

  • → means "should learn before" (hard prerequisite — you will be lost without it)
  • ⇢ means "helps to know" (soft prerequisite — useful context, not blocking)
  • Topics at the same indent level can be learned in any order relative to each other
  • Topics not listed here have no strong prerequisites and can be picked up any time

The Graph

Foundation Layer — Learn First

These topics underpin everything else. No prerequisites required beyond basic computer literacy.

linux-ops → linux-users-and-permissions → linux-hardening
         → linux-text-processing
         → linux-boot-process
         → package-management
         → systemctl-journalctl → linux-ops-systemd → linux-signals-and-process-control
         → linux-logging
         → process-management

git → git-advanced → git-advanced

networking → subnetting-and-ip-addressing → routing → vlans
                                          → arp
                                          → stp
                                          → mtu

yaml-json-config → jq
ssh-deep-dive
pipes-and-redirection → xargs → awk → sed
environment-variables
tar-and-compression
cron-scheduling

Infrastructure Layer — Build on Foundations

Requires: linux-ops, networking, git, yaml-json-config

linux-ops
linux-memory-management
linux-ops-storage → disk-and-storage-ops → mounts-filesystems → inodes
                                         → storage-ops → ceph → s3-object-storage
                  → linux-performance → linux-performance → linux-kernel-tuning
                                                              → perf-profiling
                                                              → continuous-profiling
                                                              → strace
                                                              → ebpf-observability
                  → proc-filesystem
                  → kernel-troubleshooting

networking → tcp-ip-deep-dive → tls → tls-pki → tls-certificates-ops
           → dns-ops → dns-deep-dive → dnssec → aws-route53
           → iptables-nftables → firewalls → nat
           → load-balancing → nginx-web-servers → api-gateways
           → vpn-tunneling → tailscale
           → networking-troubleshooting → networking-troubleshooting-tools → wireshark
           → http-protocol → grpc → graphql
           → bgp-evpn-vxlan
           → dhcp-ipam
           → lacp
           → cisco-fundamentals-for-devops

docker → containers-deep-dive → cgroups-namespaces → containers-deep-dive
       → container-images → container-images → container-images
       → supply-chain-security
       → security-scanning

terraform → terraform-deep-dive
          → opentofu
          → pulumi

ansible → ansible-deep-dive

Operations Layer — Build on Infrastructure

Requires: docker, terraform, git-advanced, networking, tls

docker → k8s-ops → k8s-pods-and-scheduling → k8s-ops (Probes)
                                            → k8s-ops (HPA)
                                            → oomkilled
                                            → crashloopbackoff
               → k8s-services-and-ingress → k8s-networking → cilium
                                                            → service-mesh → istio → envoy
               → k8s-storage
               → k8s-rbac → open-policy-agent → policy-engines
               → k8s-node-lifecycle → node-maintenance
               → k8s-debugging-playbook → infra-forensics
               → k8s-ecosystem → crossplane
               → k8s-ops (HPA)
               → etcd
               → k8s-ecosystem

k8s-ops → helm → kustomize → argocd-gitops → gitops → argo-workflows
               → cert-manager
               → progressive-delivery

terraform → gitops → dagger
git-advanced → cicd → ci-cd-patterns → cicd-pipelines-realities
                    → github-actions → dora-metrics
                    → feature-flags
                    → make-and-build-systems

monitoring-fundamentals → prometheus-deep-dive → alerting-rules → slo-tooling → postmortem-slo
                        → logging → log-pipelines → elasticsearch
                                  → kafka
                        → opentelemetry → tracing → continuous-profiling
                        → observability-deep-dive → synthetic-monitoring
                        → aws-cloudwatch
                        → audit-logging

sre-practices → incident-triage → incident-command → incident-psychology
             → runbook-craft → debugging-methodology
             → chaos-engineering → load-testing
             → capacity-planning → finops
             → disaster-recovery → backup-restore

Cloud Layer — Build on Operations

Requires: k8s-ops, terraform, monitoring-fundamentals

cloud-ops-basics → cloud-deep-dive
                 → aws-ec2 → aws-networking → aws-ecs → aws-lambda
                 → aws-iam
                 → aws-s3-deep-dive
                 → aws-cloudwatch
                 → aws-troubleshooting
                 → gcp-troubleshooting
                 → azure-troubleshooting

k8s-ops → multi-tenancy → platform-engineering → backstage
        → fleet-ops
        → bare-metal-provisioning → server-hardware → dell-poweredge → ipmi-and-ipmitool
                                                                      → redfish
                                  → virtualization → homelab
                                  → datacenter → datacenter
                                               → disk-and-storage-ops
                                               → power
                                               → firmware

Security Layer — Cross-Cutting Concerns

Soft prerequisites for all infrastructure/ops work. Hard prerequisites for anything security-focused.

security-basics → secrets-management → hashicorp-vault → consul
               → selinux-apparmor → linux-hardening
               → offensive-security-basics
               → opsec-mistakes
               → compliance-automation → audit-logging
               → supply-chain-security → container-images → falco
               → identity-management → ldap-identity → aws-iam

Data Layer — Stateful Systems

Requires: linux-ops, networking, docker

sql-fundamentals → postgresql → database-internals → database-ops
                → mysql-ops
                → sqlite
redis → message-queues → kafka → rabbitmq
sql-fundamentals → mongodb-ops

Professional/Meta Layer

No hard technical prerequisites. Recommended after 3-6 months of hands-on work.

sre-practices → postmortem-slo → ops-war-stories → legacy-archaeology → infra-forensics
debugging-methodology → infra-testing
monitoring-migration → observability-deep-dive

Dependency Matrix (Machine-Readable)

Topic Hard Prerequisites Soft Prerequisites
linux-ops — —
linux-users-and-permissions linux-ops —
linux-hardening linux-users-and-permissions, security-basics selinux-apparmor
linux-text-processing linux-ops pipes-and-redirection
linux-boot-process linux-ops —
linux-ops-systemd linux-ops, systemctl-journalctl —
linux-signals-and-process-control linux-ops-systemd, process-management —
linux-memory-management linux-ops proc-filesystem
linux-logging linux-ops linux-ops-systemd
linux-performance linux-performance linux-memory-management, strace
linux-kernel-tuning linux-performance proc-filesystem
linux-ops linux-ops, networking tcp-ip-deep-dive
linux-ops-storage linux-ops disk-and-storage-ops
linux-performance linux-ops linux-memory-management
process-management linux-ops —
proc-filesystem linux-ops —
kernel-troubleshooting linux-performance, linux-kernel-tuning strace, ebpf-observability
systemctl-journalctl linux-ops —
disk-and-storage-ops linux-ops linux-ops-storage
mounts-filesystems disk-and-storage-ops inodes
inodes linux-ops —
storage-ops disk-and-storage-ops —
ceph storage-ops —
s3-object-storage cloud-ops-basics storage-ops
git — —
git-advanced git —
git-advanced git-advanced —
networking — —
subnetting-and-ip-addressing networking —
routing subnetting-and-ip-addressing —
vlans networking, routing —
arp networking subnetting-and-ip-addressing
stp networking, vlans —
mtu networking, tcp-ip-deep-dive —
tcp-ip-deep-dive networking subnetting-and-ip-addressing
tls tcp-ip-deep-dive —
tls-pki tls —
tls-certificates-ops tls-pki —
dns-ops networking —
dns-deep-dive dns-ops tcp-ip-deep-dive
dnssec dns-deep-dive tls-pki
iptables-nftables linux-ops tcp-ip-deep-dive
firewalls iptables-nftables —
nat iptables-nftables, routing —
load-balancing networking, tls —
nginx-web-servers load-balancing, linux-ops —
api-gateways nginx-web-servers tls, grpc
http-protocol tcp-ip-deep-dive tls
grpc http-protocol —
graphql http-protocol —
vpn-tunneling networking, tls iptables-nftables
tailscale vpn-tunneling —
bgp-evpn-vxlan routing, vlans tcp-ip-deep-dive
dhcp-ipam networking —
lacp networking, vlans —
cisco-fundamentals-for-devops networking subnetting-and-ip-addressing
networking-troubleshooting networking, tcp-ip-deep-dive dns-ops, tls
networking-troubleshooting-tools networking-troubleshooting wireshark
wireshark tcp-ip-deep-dive —
yaml-json-config — —
jq yaml-json-config —
ssh-deep-dive linux-ops, networking tls
pipes-and-redirection linux-ops —
xargs pipes-and-redirection —
awk pipes-and-redirection —
sed pipes-and-redirection —
tar-and-compression linux-ops —
cron-scheduling linux-ops —
environment-variables linux-ops —
docker linux-ops, networking cgroups-namespaces
containers-deep-dive docker cgroups-namespaces
cgroups-namespaces linux-ops —
containers-deep-dive docker, containers-deep-dive —
container-images docker linux-ops
container-images container-images —
container-images container-images, security-basics —
supply-chain-security container-images security-basics
falco container-images, k8s-ops —
terraform yaml-json-config, git cloud-ops-basics
terraform-deep-dive terraform —
opentofu terraform —
pulumi terraform, python-infra —
ansible linux-ops, yaml-json-config ssh-deep-dive
ansible-deep-dive ansible —
k8s-ops docker, networking yaml-json-config
k8s-pods-and-scheduling k8s-ops —
k8s-ops (Probes) k8s-pods-and-scheduling —
k8s-ops (HPA) k8s-pods-and-scheduling, monitoring-fundamentals —
oomkilled k8s-pods-and-scheduling, linux-memory-management —
crashloopbackoff k8s-pods-and-scheduling linux-ops
k8s-services-and-ingress k8s-ops, load-balancing tls
k8s-networking k8s-services-and-ingress, tcp-ip-deep-dive cilium
cilium k8s-networking ebpf-observability
service-mesh k8s-networking —
istio service-mesh envoy
envoy load-balancing, http-protocol —
k8s-storage k8s-ops, storage-ops —
k8s-rbac k8s-ops, security-basics —
open-policy-agent k8s-rbac —
policy-engines open-policy-agent —
k8s-node-lifecycle k8s-ops linux-ops
node-maintenance k8s-node-lifecycle linux-ops
k8s-debugging-playbook k8s-ops linux-performance
infra-forensics k8s-debugging-playbook, debugging-methodology —
k8s-ecosystem k8s-ops —
crossplane k8s-ecosystem, terraform —
etcd k8s-ops, distributed-systems —
k8s-ecosystem k8s-ops —
helm k8s-ops, yaml-json-config —
kustomize k8s-ops, yaml-json-config helm
argocd-gitops helm, git-advanced —
gitops argocd-gitops —
argo-workflows argocd-gitops, gitops —
cert-manager helm, tls-pki —
progressive-delivery argocd-gitops helm
cicd git, yaml-json-config docker
ci-cd-patterns cicd —
cicd-pipelines-realities cicd, ci-cd-patterns —
github-actions cicd, git —
dora-metrics cicd monitoring-fundamentals
feature-flags cicd —
make-and-build-systems linux-ops —
dagger docker, cicd —
monitoring-fundamentals — networking
prometheus-deep-dive monitoring-fundamentals, k8s-ops —
alerting-rules prometheus-deep-dive slo-tooling
slo-tooling monitoring-fundamentals alerting-rules
postmortem-slo slo-tooling sre-practices
logging linux-logging, linux-ops —
log-pipelines logging kafka
elasticsearch log-pipelines —
opentelemetry monitoring-fundamentals tracing
tracing opentelemetry —
continuous-profiling linux-performance, tracing —
observability-deep-dive prometheus-deep-dive, tracing log-pipelines
synthetic-monitoring monitoring-fundamentals —
audit-logging logging, security-basics —
sre-practices monitoring-fundamentals incident-triage, postmortem-slo
incident-triage sre-practices runbook-craft
incident-command incident-triage —
incident-psychology incident-command —
runbook-craft linux-ops —
debugging-methodology linux-ops —
chaos-engineering k8s-ops, sre-practices load-testing
load-testing networking, monitoring-fundamentals —
capacity-planning sre-practices, monitoring-fundamentals —
disaster-recovery backup-restore —
backup-restore storage-ops —
finops cloud-ops-basics, capacity-planning —
security-basics linux-ops, networking —
secrets-management security-basics hashicorp-vault
hashicorp-vault secrets-management consul
consul networking —
selinux-apparmor linux-users-and-permissions, security-basics —
offensive-security-basics security-basics, networking tls
opsec-mistakes security-basics —
compliance-automation security-basics audit-logging
ldap-identity networking, security-basics —
cloud-ops-basics linux-ops, networking —
cloud-deep-dive cloud-ops-basics k8s-ops, terraform
aws-ec2 cloud-ops-basics linux-ops
aws-networking aws-ec2, networking vpc-concepts
aws-iam aws-ec2, security-basics —
aws-ecs aws-ec2, docker —
aws-lambda aws-ec2 —
aws-s3-deep-dive cloud-ops-basics s3-object-storage
aws-cloudwatch monitoring-fundamentals, aws-ec2 —
aws-route53 dns-ops, aws-ec2 —
aws-troubleshooting aws-ec2, aws-networking debugging-methodology
gcp-troubleshooting cloud-ops-basics debugging-methodology
azure-troubleshooting cloud-ops-basics debugging-methodology
multi-tenancy k8s-ops k8s-rbac
platform-engineering k8s-ops, multi-tenancy backstage
backstage platform-engineering —
fleet-ops k8s-ops, ansible —
bare-metal-provisioning linux-ops, ansible server-hardware
server-hardware — —
dell-poweredge server-hardware ipmi-and-ipmitool
ipmi-and-ipmitool server-hardware —
redfish ipmi-and-ipmitool —
virtualization linux-ops server-hardware
homelab virtualization, linux-ops —
datacenter server-hardware —
datacenter datacenter, ipmi-and-ipmitool —
disk-and-storage-ops datacenter, disk-and-storage-ops —
sql-fundamentals — —
postgresql sql-fundamentals database-internals
database-internals sql-fundamentals distributed-systems
database-ops postgresql backup-restore
mysql-ops sql-fundamentals —
sqlite sql-fundamentals —
redis — networking
message-queues networking —
kafka message-queues —
rabbitmq message-queues —
mongodb-ops — database-internals
distributed-systems networking, linux-ops —
perf-profiling linux-performance strace
strace linux-ops, process-management —
ebpf-observability linux-performance —
python-infra linux-ops yaml-json-config
python-debugging python-infra strace
python-async-concurrency python-infra distributed-systems
python-packaging python-infra —
grep-and-regex linux-text-processing —
regex-text-wrangling grep-and-regex sed, awk
find linux-ops —
fd modern-cli find
fzf modern-cli —
ripgrep modern-cli, grep-and-regex —
modern-cli linux-ops —
modern-cli-workflows modern-cli —
terminal-internals linux-ops —
tmux-and-screen terminal-internals —
vscode — —
ai-devops-tools linux-ops cicd
ai-ml-ops ai-devops-tools k8s-ops, monitoring-fundamentals
infra-testing cicd terraform
monitoring-migration monitoring-fundamentals prometheus-deep-dive
legacy-archaeology linux-ops debugging-methodology
ops-war-stories sre-practices —
binary-and-floats — —
statistics-and-data-reasoning — —
distributed-systems networking —
dagger docker, cicd —
nix linux-ops package-management
powershell — linux-ops
rhce linux-ops, ansible —
lpic-lfcs linux-ops —
wasm-infrastructure containers-deep-dive —
edge-iot linux-ops, networking —
packer docker, ansible —