Skip to main content

90-Day Linux/SRE Mastery Roadmap

How This Roadmap Is Structured​

  • Phase 1 (Days 1–30) → Core Linux control
  • Phase 2 (Days 31–60) → Performance & debugging depth
  • Phase 3 (Days 61–90) → Production-level SRE mastery

Each phase includes: Concepts, Commands to master, Labs, Expected outcome.

Table of Contents​

  1. Phase 1 — Linux Foundations (Days 1–30)
  2. Phase 2 — Performance & Debugging Depth (Days 31–60)
  3. Phase 3 — Production SRE Mastery (Days 61–90)
  4. Daily Habit
  5. Final Skill Checklist
🧭 Mental modelThe 90-day roadmap as one continuous timelineThree sequential 30-day phases carry a learner from basic Linux comfort, through performance-debugging depth, to production-grade SRE mastery, each phase building directly on the last.Phase 1: Days 1-30core Linux controlPhase 2: Days 31-60performance & debugging depthPhase 3: Days 61-90production-level masteryDay 1Day 90Production-Grade SREgoal state

The 90 days are one continuous timeline, not three separate courses: Phase 1 builds core Linux control, Phase 2 adds performance-debugging depth on top of it, and Phase 3 turns that combination into production-grade SRE mastery.

🔵 PHASE 1 — Linux Foundations (Days 1–30)​

Goal: Become comfortable living inside Linux without fear.

✅ Week 1 — Filesystem & Shell Mastery​

Concepts: filesystem hierarchy, inodes, file descriptors, permissions (rwx, SUID, SGID, sticky bit), environment variables

Commands: ls, stat, file, find, xargs, chmod, chown, du, df, mount, umount, lsblk, lsof

Lab:

  • Fill disk to 95% → debug it
  • Exhaust inodes → fix it
  • Break permissions → repair them
  • Trace which process is holding a deleted file open

Outcome: You can debug "disk full" in under 10 minutes.

✅ Week 2 — Process & Service Control​

Concepts: PID/PPID, zombie processes, signals, daemons, systemd internals

Commands: ps aux, top/htop, pstree, kill/kill -9, nice/renice, systemctl, journalctl

Lab:

  • Create zombie processes intentionally
  • Write a broken systemd service and debug it
  • Crash a service and analyze logs

Outcome: You can debug "service not starting" confidently.

✅ Week 3 — Networking Essentials​

Concepts: TCP 3-way handshake, SYN backlog, TIME_WAIT, DNS resolution flow, routing tables, NAT basics

Commands: ip a, ip route, ss -tulpn, tcpdump, netstat, dig, curl, nc, traceroute

Lab:

  • Break DNS → fix it
  • Simulate port conflicts
  • Capture and analyze a TCP handshake
  • Block traffic with a firewall → debug it

Outcome: You can debug "service unreachable" end-to-end.

✅ Week 4 — Storage & Memory​

Concepts: virtual memory, page cache, swap, OOM killer, IOPS/latency/throughput, LVM basics

Commands: free -m, vmstat, iostat, iotop, lsblk, df -i, dmesg

Lab:

  • Trigger the OOM killer
  • Saturate disk I/O
  • Create and extend LVM volumes
  • Analyze memory pressure

Outcome: You understand what "high load" actually means.

🟡 PHASE 2 — Performance & Debugging Depth (Days 31–60)​

Goal: Think like the kernel.

✅ Week 5 — CPU & Load Deep Dive​

Concepts: load average meaning, run queue, context switching, CPU steal time (VMs), interrupts

Tools: uptime, mpstat, pidstat, sar, vmstat, perf top

Lab:

  • Create a CPU-bound process
  • Analyze CPU saturation
  • Measure context switches

Outcome: You can explain why load is high.

✅ Week 6 — Advanced Memory Debugging​

Concepts: memory leaks, RSS vs VSZ, page faults, overcommit behavior, huge pages

Tools: smem, pmap, cat /proc/meminfo, cat /proc/<pid>/smaps

Lab:

  • Simulate a memory leak
  • Compare memory usage across processes
  • Debug OOM logs

Outcome: You can debug "server slow after 3 days."

✅ Week 7 — I/O & Filesystem Internals​

Concepts: I/O scheduler, queue depth, fsync impact, journaling

Tools: iostat -x, blktrace, dstat, lsof

Lab:

  • Create a heavy write workload
  • Observe iowait behavior
  • Compare SSD vs HDD latency

Outcome: You can debug disk bottlenecks like a senior engineer.

✅ Week 8 — Strace, Lsof & System Call Debugging​

Concepts: system calls, blocking vs non-blocking I/O, file descriptor leaks

Tools: strace, lsof, watch

Lab:

  • Trace a failing process
  • Identify a hanging syscall
  • Detect an FD leak

Outcome: You stop guessing. You start proving.

🔴 PHASE 3 — Production SRE Mastery (Days 61–90)​

Goal: Operate like you're on-call for a major system.

✅ Week 9 — Networking at Scale​

Concepts: SYN flood, ephemeral port exhaustion, TCP retransmissions, MTU mismatch, keepalive behavior

Tools: ss -s, tcpdump -i any, netstat -an, ethtool

Lab:

  • Simulate connection exhaustion
  • Analyze packet drops
  • Tune TCP parameters

✅ Week 10 — Containers & cgroups​

Concepts: namespaces, cgroups v1/v2, CPU shares, memory limits, PID namespace

Tools: docker stats, docker inspect, cat /sys/fs/cgroup/*

Lab:

  • Constrain container memory
  • Trigger a container OOM
  • Debug container networking

✅ Week 11 — Observability Mindset​

Learn:

  • USE Method (Utilization, Saturation, Errors)
  • RED Method (Rate, Errors, Duration)
  • How Linux metrics map to SRE dashboards

Read:

  • Systems Performance by Brendan Gregg
  • Site Reliability Engineering by Google

✅ Week 12 — Chaos & Failure Simulation​

Now simulate real incidents:

  • Disk full
  • Memory exhaustion
  • CPU saturation
  • DNS failure
  • Network partition
  • File descriptor exhaustion
  • Kernel panic (VM only)

Practice debugging under time pressure.

🧠 Daily Habit (Throughout 90 Days)​

Every single day:

  • Spend 30 minutes reading /proc
  • Use man pages instead of Google
  • Break something intentionally
  • Write a postmortem

🔥 Final Skill Checklist (If You Can Do These, You're Strong)​

You can:

  • Explain load average clearly
  • Debug high CPU in under 5 minutes
  • Diagnose OOM cause from logs
  • Trace a hanging process with strace
  • Identify disk saturation
  • Analyze a TCP handshake via tcpdump
  • Debug container resource limits
  • Recover from a broken systemd service

🏁 After 90 Days​

You won't just "know Linux." You will:

  • Think in queues
  • See bottlenecks
  • Understand kernel states
  • Debug calmly under pressure

Summary​

  • 💡 Each phase builds on the last — don't skip to containers/cgroups (Week 10) before internalizing CPU/memory/disk fundamentals (Weeks 1–8).
  • 🔥 The daily /proc habit is what converts memorized commands into intuition.
  • ✅ Week 12's chaos simulation is the real test — pair it directly with Incident Simulation Labs.

See Also​