A self-paced path through DevOps, SRE and machine learning

You will be able to

• •Explain kernel vs shell vs user space
• •Navigate the FHS: /etc, /var/log, /proc
• •Redirect stdout/stderr like a cron job
• •Read and set permissions in octal

Read

• Linux for DevOps — full chapter

Chapters & labs in this stage (0/3)

• Lesson 01: Linux Fundamentals for DevOps Engineers
• Lesson 02: All 70 Essential Linux Commands for DevOps
• Lesson 03: 70 Essential Linux Commands Quick Reference

Hands-on: Build a tiny log pipeline

1. Start an Ubuntu container or VM
2. Write a script that prints to stdout and stderr
3. Capture both into one log and rotate it by date
4. Find the 5 most frequent error lines with grep, sort and uniq

docker run -it --rm ubuntu:24.04 bash

cat > worker.sh <<'SH'
#!/usr/bin/env bash
echo "job started"
echo "disk warning" >&2
SH
chmod 755 worker.sh
./worker.sh > "worker-$(date +%F).log" 2>&1
grep -i warning worker-*.log | sort | uniq -c | sort -rn | head -5

Done when

• You can explain what 2>&1 does and why order matters
• You can read `ls -l` output and convert it to octal

You will be able to

• •Explain OSI and TCP/IP layer by layer
• •Subnet with CIDR and VLSM by hand
• •Trace DNS, TCP and HTTP end to end
• •Design a small campus or branch network

Read

• Start at Networking 01 — Foundations

Chapters & labs in this stage (0/10)

• Networking 01 — Foundations: LAN, MAN, WAN, Topologies and Protocols
• Networking 02 — Devices: Hubs, Repeaters, Bridges, Switches, Routers and Middleboxes
• Networking 03 — The OSI and TCP/IP Models, Multiplexing and Demultiplexing
• Networking 04 — IP Addressing: Classful, Subnetting, CIDR, NAT, DHCP and IPv6
• Networking 05 — Inside IPv4: The Header, Options, Fragmentation, TTL and Routing
• Networking 06 — Transport: TCP, UDP, the Three-Way Handshake, Timers and Ports
• Networking 07 — Application Layer: DNS, HTTP, Status Codes, Cookies, FTP and Email
• Networking 08 — How the Internet Works, End to End
• Networking 09 — Designing a Network in Eight Steps (with Five Case Studies)
• Networking 10 — Worked Problems, Model Questions and Past Papers

Hands-on: Read the network you're on

1. Find your local IP, gateway and DNS server
2. Work out your subnet's network and broadcast address by hand
3. Trace a DNS lookup and a TCP connection to a real site
4. Design an addressing plan for a 3-department office with VLSM

ip addr show            # or: ifconfig
ip route | grep default
cat /etc/resolv.conf
dig +trace example.com
curl -v https://example.com 2>&1 | head -20
traceroute example.com

Done when

• You can subnet a /24 into four /26s without a calculator
• You can explain every line of `curl -v` output

You will be able to

• •Explain namespaces vs cgroups
• •Order a Dockerfile for cache hits
• •Write a multi-stage build
• •Run a multi-service stack with Compose

Read

• Docker in production — 4 chapters

Chapters & labs in this stage (0/4)

• Lesson 04: Containers vs Virtual Machines & Docker Architecture
• Lesson 05: Essential Docker CLI Commands & Lifecycle
• Lesson 06: Dockerfile Engineering & Multi-Stage Optimization
• Lesson 07: Docker Compose for Multi-Container Systems

Hands-on: Containerise a web app properly

1. Write a Dockerfile that copies the lockfile before the source
2. Add a HEALTHCHECK and read PORT from the environment
3. Convert it to a multi-stage build and compare image sizes
4. Add Postgres with docker compose and a named volume

docker build -t myapp:dev .
docker images myapp
docker run --rm -p 8000:8000 -e PORT=8000 myapp:dev
docker inspect --format='{{json .State.Health}}' $(docker ps -q -l)
docker compose up -d && docker compose ps

Done when

• A code-only change rebuilds in seconds
• `docker inspect` reports the container as healthy

You will be able to

• •Name every control-plane and node component
• •Choose Deployment vs StatefulSet vs DaemonSet
• •Expose a service with ClusterIP and Ingress
• •Debug a crashing pod with kubectl

Read

• Kubernetes from the control plane down

Chapters & labs in this stage (0/4)

• Lesson 08: Kubernetes Cluster Architecture
• Lesson 09: Kubernetes Workloads: From Pods to Deployments
• Lesson 10: Kubernetes Services & Ingress Routing
• Lesson 11: Essential Kubectl Commands & Production Debugging

Hands-on: Run and break a deployment locally

1. Create a kind or minikube cluster
2. Deploy your Stage 2 image with liveness/readiness probes and limits
3. Set a memory limit too low and watch it get OOMKilled
4. Fix it, then roll out a new version with zero downtime

kind create cluster --name lab
kubectl apply -f deployment.yaml
kubectl get pods -w
kubectl describe pod <pod>        # look for OOMKilled / exit 137
kubectl logs <pod> --previous
kubectl rollout status deploy/myapp

Done when

• You've seen exit code 137 and know what it means
• A rolling update completed with no failed requests

You will be able to

• •Use IAM roles instead of access keys
• •Mount an EBS volume on EC2
• •Host an SPA on S3 with correct routing
• •Calculate usable IPs in a subnet
• •Provision with Terraform

Read

• AWS hands-on — 5 chapters

Chapters & labs in this stage (0/5)

• Lesson 12: AWS Cloud Architecture & Identity Access Management (IAM)
• Lesson 13: Amazon EC2 (Elastic Compute Cloud) & EBS Volumes
• Lesson 14: Amazon S3 (Simple Storage Service) & Static Hosting
• Lesson 15: Amazon Virtual Private Cloud (VPC) Networking
• Lesson 16: Infrastructure as Code (IaC) with Terraform on AWS

Hands-on: Terraform a small public web tier

1. Write main.tf with a VPC, public subnet, security group and EC2 instance
2. Bootstrap Nginx with user data
3. Attach an IAM role that can only read one S3 bucket
4. Destroy everything when done — and check the bill

terraform init
terraform plan -out tfplan
terraform apply tfplan
curl -I http://$(terraform output -raw public_ip)
terraform destroy

Done when

• No access keys exist on the instance
• `terraform destroy` leaves nothing behind

You will be able to

• •Set a budget alert first
• •Create a VM and firewall rule with gcloud
• •Pick the right GCS storage class
• •Deploy a container to Cloud Run

Read

• Google Cloud essentials
• Case study: Nora Labs on Cloud Run

Chapters & labs in this stage (0/4)

• Lesson 17: Google Cloud Platform (GCP) Fundamentals
• Lesson 18: Google Compute Engine (GCE) & Instance Groups
• Lesson 19: Google Cloud Storage (GCS)
• Lesson 20: Google Kubernetes Engine (GKE) & Operations

Hands-on: Ship your Stage 2 image to Cloud Run

1. Create a budget with an email alert
2. Create an Artifact Registry repo
3. Build for linux/amd64 and push
4. Deploy with an explicit max-instances and memory

gcloud artifacts repositories create lab --repository-format=docker --location=us-central1
docker buildx build --platform linux/amd64 -t us-central1-docker.pkg.dev/$PROJECT/lab/myapp:v1 --push .
gcloud run deploy myapp --image=us-central1-docker.pkg.dev/$PROJECT/lab/myapp:v1 \
  --region=us-central1 --allow-unauthenticated --max-instances=2 --memory=512Mi

Done when

• The service URL returns 200
• You know what happens to files written inside the container

You will be able to

• •Trace a request from DNS to upstream
• •Harden SSH with ed25519 keys
• •Write an Nginx reverse proxy with WebSockets
• •Issue TLS with Certbot
• •Fix SPA 404s on a CDN

Read

• Production web infrastructure
• Case study: static client sites

Chapters & labs in this stage (0/3)

• Lesson 21: Production Deployment Foundations: From Bare Metal to Cloud
• Lesson 22: Nginx: The Universal Reverse Proxy & Web Server
• Lesson 23: Storage & Distribution: S3 + CloudFront CDN

Hands-on: Put a real domain in front of an app

1. Point an A record at a VM
2. Disable password SSH login
3. Proxy to your app with Nginx, forwarding client IPs
4. Add TLS with Certbot and confirm auto-renewal

dig +short app.example.com
sudo nginx -t && sudo systemctl reload nginx
sudo certbot --nginx -d app.example.com
sudo certbot renew --dry-run
curl -I https://app.example.com

Done when

• HTTPS works and renew --dry-run passes
• Your app logs show real client IPs, not 127.0.0.1

You will be able to

• •Install Coolify on a VM
• •Open the right firewall ports
• •Connect a second server over SSH
• •Deploy an app from a Git repo

Read

• Self-hosting with Coolify

Chapters & labs in this stage (0/2)

• Lesson 24: Coolify: The Open-Source Self-Hosted PaaS
• Lesson 25: Connecting Remote Servers to Coolify (Step-by-Step)

Hands-on: Your own PaaS

1. Create an e2 VM and allow 22, 80, 443 and 8000
2. Install Coolify
3. Add Coolify's key to a second server's authorized_keys
4. Validate the server and deploy a repo with a custom domain

curl -fsSL https://cdn.coollabs.io/coolify/install.sh | sudo bash
mkdir -p ~/.ssh && chmod 700 ~/.ssh
echo "<coolify public key>" >> ~/.ssh/authorized_keys
chmod 600 ~/.ssh/authorized_keys

Done when

• The server shows as validated
• A git push redeploys the app with HTTPS

You will be able to

• •Test before you build, build before you deploy
• •Deploy immutable SHA-tagged images
• •Authenticate CI with Workload Identity Federation
• •Write an SLO and an error budget policy

Read

• How I ship 23 projects
• SRE in practice

Chapters & labs in this stage (0/1)

• Lesson 26: DevOps & Cloud Engineering Comprehensive Quiz

Hands-on: Capstone: a pipeline you'd trust

1. GitHub Actions: lint + tests + import smoke test on every PR
2. On main: WIF auth, build, push :$SHA, deploy that SHA
3. Write a 99.9% SLO for your service and compute the monthly budget
4. Break a deploy on purpose and roll back to the previous SHA

# permissions needed for keyless auth
permissions:
  contents: read
  id-token: write

# roll back = redeploy the previous image
gcloud run deploy myapp --image=$REGION-docker.pkg.dev/$PROJECT/lab/myapp:$PREVIOUS_SHA

Done when

• No cloud keys are stored in GitHub secrets
• You can roll back in under 5 minutes

You will be able to

• •Explain user space vs kernel space and syscalls
• •Find what's using a port, a file or the memory
• •Read OOM-killer evidence in the kernel log
• •Manage a service with systemd and journalctl

Read

• Start at Lab 01 — Ground Zero

Chapters & labs in this stage (0/9)

• SRE Lab 01: Ground Zero: Computer Hardware, Kernel Space, User Space & Syscalls
• SRE Lab 02: Linux Terminal, Bash Shell & Standard Streams (I/O & Pipes)
• SRE Lab 03: Linux Filesystem Hierarchy & Inodes ('Everything is a File')
• SRE Lab 04: Linux Permissions, Ownership, Chmod & Chown Security
• SRE Lab 05: Linux Process Management, Job Control & POSIX Signals
• SRE Lab 06: Linux Virtual Memory, Paging, Swap & The Out-of-Memory (OOM) Killer
• SRE Lab 07: Linux Systemd Init System (PID 1), Daemons & Centralized Logging
• SRE Lab 08: Linux Networking from Scratch: TCP/IP, Sockets, Ports & DNS
• SRE Lab 09: Remote Access with SSH Keys & Linux Package Management

Hands-on: Diagnose a sick server

1. Run Labs 01–09 in order — each builds on the last
2. Fill a disk and watch what breaks first
3. Trigger an OOM kill in a container with a 64 MB limit
4. Write a systemd unit that restarts on failure and read its logs

df -h && du -sh /var/log/* | sort -h | tail
ss -tulpn | grep LISTEN
ps -eo pid,ppid,stat,%mem,cmd --sort=-%mem | head
dmesg -T | grep -i 'killed process'
sudo systemctl status myapp && journalctl -u myapp -n 50 --no-pager

Done when

• You can name the process holding any port
• You've read a real OOM-kill line and know exit code 137

You will be able to

• •Design for AZ failure
• •Explain containers as namespaces + cgroups
• •Make Kubernetes self-heal with probes
• •Build a pipeline that blocks bad deploys

Read

• Continue at Lab 10 — Regions & AZs

Chapters & labs in this stage (0/9)

• SRE Lab 10: Cloud Computing Foundations: AWS Regions & Availability Zones
• SRE Lab 11: AWS EC2 Instances, EBS Volumes & Security Groups
• SRE Lab 12: What is DevOps? Culture, CAMS & Git Version Control
• SRE Lab 13: Docker Deep Dive 1: Containers Under the Hood (Namespaces & Cgroups)
• SRE Lab 14: Docker Deep Dive 2: Dockerfiles, Multi-Stage Builds & Volumes
• SRE Lab 15: Kubernetes (K8s) Architecture: Control Plane & Worker Nodes
• SRE Lab 16: Kubernetes Hands-on: Pods, Deployments & Self-Healing
• SRE Lab 17: Kubernetes Networking, Services, Scaling & Rolling Updates
• SRE Lab 18: CI/CD Automation with Jenkins, Git, Docker & Kubernetes

Hands-on: Self-healing on purpose

1. Work through Labs 10–18
2. Kill a pod and time how long Kubernetes takes to replace it
3. Ship a broken image and confirm the readiness probe stops the rollout
4. Roll back with one command

kubectl delete pod -l app=myapp --wait=false && kubectl get pods -w
kubectl set image deploy/myapp app=myapp:broken
kubectl rollout status deploy/myapp --timeout=60s
kubectl rollout undo deploy/myapp

Done when

• A bad image never receives traffic
• You can roll back in under a minute

You will be able to

• •Write an SLI and SLO for a real service
• •Compute error budgets and burn rates
• •Instrument the four golden signals
• •Run a blameless postmortem

Read

• Lab 19 — SLI, SLO, SLA & error budgets
• SRE in practice — budget policy & postmortems

Chapters & labs in this stage (0/2)

• SRE Lab 19: Site Reliability Engineering (SRE), SLI, SLO, SLA & Error Budgets
• SRE Lab 20: Observability, The Four Golden Signals & SRE Graduation Exam

Hands-on: Capstone: an SLO for one of your services

1. Pick a service from Stage 6 or 9 and define one availability and one latency SLI
2. Set a 30-day SLO and compute the budget in minutes
3. Define 14.4× / 1h and 6× / 6h burn-rate alerts
4. Simulate an incident and write the postmortem with action items

python3 -c "mins=30*24*60; slo=0.999; print(f'budget: {mins*(1-slo):.1f} min')"
python3 -c "err=0.0144; slo=0.001; print(f'burn rate: {err/slo:.1f}x')"

Done when

• Your SLO and budget are written down
• You have a postmortem with owners and due dates

You will be able to

• •Work through all 24 lessons in Python & Data Basics
• •Re-run every notebook cell yourself
• •Explain each output before moving on

Read

• Start at ML 01: Google Colaboratory Basics

Chapters & labs in this stage (0/24)

• ML 01: Google Colaboratory Basics
• ML 02: Python Basics
• ML 03: Basic Data Types in Python
• ML 04: List Tuple Set Dictionary
• ML 05: Operators in Python
• ML 06: If else statement in Python
• ML 07: Loops in Python
• ML 08: Functions in Python
• ML 09: Complete Numpy Tutorial in Python
• ML 10: Complete Pandas Tutorial in Python
• ML 11: Matplotlib Tutorial in Python
• ML 12: Seaborn Tutorial in Python
• ML 13: Importing Datasets through Kaggle API
• ML 14: Handling Missing Values
• ML 15: Data Standardization
• ML 16: Label Encoding
• ML 17: Train Test Split
• ML 18: Handling imbalanced Dataset
• ML 19: Feature extraction of Text data using Tf idf Vectorizer
• ML 20: Numerical Dataset Pre Processing Use Case
• ML 21: Text Data Pre Processing Use Case
• ML 22: ML Use Case 1 Rock vs Mine Prediction
• ML 23: ML Use case 2 Diabetes Prediction
• ML 24: ML Use Case 3 Spam Mail Prediction using Machine Learning

Hands-on: Run it yourself

1. Open Google Colab (or a local Jupyter) and create a notebook per lesson
2. Type the code rather than pasting it
3. Change one parameter and predict the new output before running

pip install numpy pandas scikit-learn matplotlib seaborn
jupyter notebook

Done when

• Every lesson in this part is marked complete
• You can explain one model from this part to a friend

You will be able to

• •Work through all 7 lessons in Maths & First Models
• •Re-run every notebook cell yourself
• •Explain each output before moving on

Read

• Start at ML 25: Vector Operations in Python Part 1

Chapters & labs in this stage (0/7)

• ML 25: Vector Operations in Python Part 1
• ML 26: Vector Operations in Python Part 2
• ML 27: Working with Matrix in Python
• ML 28: Matrix Operations in Python
• ML 29: Project 4 Heart Disease Prediction
• ML 30: Project 5 House Price Prediction
• ML 31: Project 6 Loan Status Prediction

Hands-on: Run it yourself

1. Open Google Colab (or a local Jupyter) and create a notebook per lesson
2. Type the code rather than pasting it
3. Change one parameter and predict the new output before running

pip install numpy pandas scikit-learn matplotlib seaborn
jupyter notebook

Done when

• Every lesson in this part is marked complete
• You can explain one model from this part to a friend

You will be able to

• •Work through all 11 lessons in Building Models from Scratch
• •Re-run every notebook cell yourself
• •Explain each output before moving on

Read

• Start at ML 32: Building Linear Regression from scratch in Python

Chapters & labs in this stage (0/11)

• ML 32: Building Linear Regression from scratch in Python
• ML 33: Implementing Linear Regression from scratch in Python
• ML 34: Lin Reg implementation
• ML 35: Building Logistic Regression from scratch in Python
• ML 36: Implementing Logistic Regression from scratch in Python
• ML 37: Logistic Regression Implementation
• ML 38: Building Support Vector Machine Classifier from Scratch in Python
• ML 39: Implementing SVM Classifier from Scratch in Python
• ML 40: Implementing SVM from Scratch
• ML 41: Building Lasso Regression from Scratch in Python
• ML 42: Implementing Lasso Regression from Scratch

Hands-on: Run it yourself

1. Open Google Colab (or a local Jupyter) and create a notebook per lesson
2. Type the code rather than pasting it
3. Change one parameter and predict the new output before running

pip install numpy pandas scikit-learn matplotlib seaborn
jupyter notebook

Done when

• Every lesson in this part is marked complete
• You can explain one model from this part to a friend

You will be able to

• •Work through all 10 lessons in Evaluating & Choosing Models
• •Re-run every notebook cell yourself
• •Explain each output before moving on

Read

• Start at ML 43: Cross Validation Python Implementation

Chapters & labs in this stage (0/10)

• ML 43: Cross Validation Python Implementation
• ML 44: GridSearchCV and RandomizedSearchCV
• ML 45: Model Selection in ML with Python
• ML 46: Accuracy score and Confusion Matrix
• ML 47: Precision, Recall, F1 Score Python implementation
• ML 48: Project 12 Big Mart Sales Prediction
• ML 49: Project 13 Customer Segmentation using K Means Clustering
• ML 50: Project 16 Calories Burnt Prediction
• ML 51: Project 18 Movie Recommendation System using Machine Learning with Python
• ML 52: Project 19 Breast Cancer Classification using Machine Learning

Hands-on: Run it yourself

1. Open Google Colab (or a local Jupyter) and create a notebook per lesson
2. Type the code rather than pasting it
3. Change one parameter and predict the new output before running

pip install numpy pandas scikit-learn matplotlib seaborn
jupyter notebook

Done when

• Every lesson in this part is marked complete
• You can explain one model from this part to a friend

You will be able to

• •Work through all 12 lessons in Shipping Models to the World
• •Re-run every notebook cell yourself
• •Explain each output before moving on

Read

• Start at ML 53: Deploying Machine Learning model using Streamlit

Chapters & labs in this stage (0/12)

• ML 53: Deploying Machine Learning model using Streamlit
• ML 54: Multiple disease prediction system - diabetes
• ML 55: Multiple disease prediction system - heart
• ML 56: Multiple disease prediction system - Parkinsons
• ML 57: Diabetes model for API
• ML 58: Deploying ML model as public API ngrok
• ML 59: Diabetes model for API
• ML 60: Diabetes model for API
• ML 61: DL Project 1 Breast Cancer Classification with NN
• ML 62: Processing image data for Deep Learning
• ML 63: DL Project 2 MNIST Digit classification using NN
• ML 64: DL Project 3 Dog vs Cat Classification Transfer Learning

Hands-on: Run it yourself

1. Open Google Colab (or a local Jupyter) and create a notebook per lesson
2. Type the code rather than pasting it
3. Change one parameter and predict the new output before running

pip install numpy pandas scikit-learn matplotlib seaborn
jupyter notebook

Done when

• Every lesson in this part is marked complete
• You can explain one model from this part to a friend