How to Learn DevOps

DevOps is a big field, and the biggest mistake beginners make is learning the flashy tools first (Kubernetes, Terraform) before they understand the ground those tools stand on. DevOps means “Development and Operations” — the practice of building, shipping, and running software smoothly as one team. This page gives you a learning order that actually works: each topic builds on the one before it. Follow it top to bottom, and don’t skip steps.

Why order matters

Every DevOps tool is, underneath, just a program running on a Linux server, talking to other servers over a network, storing state in files or databases. If you learn Docker before you understand Linux processes and ports, Docker feels like magic — and magic breaks in confusing ways. Learn the foundation first, and every layer on top becomes obvious.

Tip: Don’t try to learn everything at once. Spend real time (weeks, not hours) on Linux and networking. Those two skills pay off in every single thing you do later.

Before you start, open the interactive DevOps roadmap on this site. It shows the same path visually and lets you check off topics as you go.

The learning order

Here is the path. The “Why” column tells you what each step unlocks.

#	Topic	Why you learn it here
1	Linux fundamentals	Every server runs Linux; this is the bedrock
2	Networking & SSH	How machines talk and how you connect to them
3	Git & version control	How code (and config) is stored and shared
4	Web servers & reverse proxies	How your app is exposed to the internet
5	Databases	How apps store data; you’ll run and back these up
6	Containers (Docker)	Package an app so it runs the same everywhere
7	CI/CD pipelines	Automate testing and deployment
8	Infrastructure as Code (IaC)	Define servers in code, not by hand
9	Monitoring & logging	Know when things break, and why

Step 1 — Linux fundamentals

A “distribution” (distro) is a packaged version of Linux. We target Ubuntu 22.04 / 24.04 LTS (LTS means Long Term Support — five years of free security updates). Learn the file system, permissions, processes, and the package manager apt.

sudo apt update && sudo apt upgrade -y
# look at running processes
ps aux | head
# check disk usage in human-readable form
df -h

Output:

Filesystem      Size  Used Avail Use% Mounted on
/dev/vda1        25G  4.2G   20G  18% /
tmpfs           2.0G     0  2.0G   0% /dev/shm

Learn systemd too — it’s the system that starts and supervises services (background programs). The command you’ll use constantly is systemctl:

sudo systemctl status ssh

Step 2 — Networking and SSH

SSH (Secure Shell) is how you log in to a remote server from your laptop. Learn IP addresses, ports (a numbered “door” on a server, e.g. 22 for SSH, 80 for web), and DNS (the system that turns example.com into an IP).

# connect to a server (replace the IP with yours)
ssh [email protected]

Then lock the front door with ufw (Uncomplicated Firewall):

sudo ufw allow OpenSSH
sudo ufw allow 80/tcp
sudo ufw enable

Security gotcha: Always run sudo ufw allow OpenSSH before sudo ufw enable. If you enable the firewall first without allowing SSH, you can lock yourself out of your own server.

Step 3 — Git and version control

Git tracks every change to your code and lets a team collaborate. In DevOps, you also keep your configuration in Git (this is called GitOps). Install it and set your identity:

sudo apt install -y git
git config --global user.name "Your Name"
git config --global user.email "[email protected]"

Step 4 — Web servers and reverse proxies

A web server delivers your site over HTTP. Nginx (pronounced “engine-x”) is the standard. It often acts as a reverse proxy — a server that sits in front of your app and forwards requests to it, handling HTTPS and caching.

sudo apt install -y nginx

A minimal reverse-proxy config in /etc/nginx/sites-available/myapp:

server {
    listen 80;
    server_name example.com;

    location / {
        proxy_pass http://127.0.0.1:3000;
        proxy_set_header Host $host;
    }
}

Enable it and reload:

sudo ln -s /etc/nginx/sites-available/myapp /etc/nginx/sites-enabled/
sudo nginx -t && sudo systemctl reload nginx

Step 5 — Databases

Most apps need a database. PostgreSQL is a great default. Learn to install it, create a database, and — most importantly — back it up.

sudo apt install -y postgresql
sudo systemctl status postgresql

Config lives under /etc/postgresql/ and logs under /var/log/postgresql/.

Step 6 — Containers (Docker)

A container packages your app with everything it needs so it runs the same on your laptop and on the server. Once you know Linux, Docker finally makes sense.

curl -fsSL https://get.docker.com | sudo sh
sudo docker run hello-world

Step 7 — CI/CD

CI/CD means Continuous Integration / Continuous Delivery — automatically testing and deploying code on every push. Start with GitHub Actions because it’s free and lives next to your code.

name: ci
on: [push]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: echo "run your tests here"

Step 8 — Infrastructure as Code

IaC means defining servers and cloud resources in code instead of clicking buttons. Terraform and Ansible are the common tools. Learn this only after you can set a server up by hand — IaC just automates what you already understand.

Step 9 — Monitoring and logging

You can’t fix what you can’t see. Learn to read logs (journalctl, /var/log/) and set up metrics with Prometheus and dashboards with Grafana.

# tail recent system logs
journalctl -xe --no-pager | tail -n 20

Practice on a real VPS

A VPS (Virtual Private Server) is a small rented Linux server, around $5/month. Reading is not enough — you learn DevOps by breaking and fixing things. Rent one, give it a real domain, deploy a small app behind Nginx with HTTPS, and automate the deploy with CI/CD. This single project touches every step above.

Tip: Treat your first VPS as disposable. Wipe and rebuild it a few times — being able to recreate a server from scratch is the core DevOps skill.

Best Practices

• Learn the foundation (Linux, networking) deeply before touching orchestration tools.
• Keep all config in Git from day one, even on a personal server.
• Always configure your firewall and SSH keys before exposing anything to the internet.
• Build one real end-to-end project rather than collecting dozens of half-finished tutorials.
• Automate a task only after you’ve done it manually and understand it.
• Set up logging and backups early — not after your first outage.
• Revisit the DevOps roadmap regularly to track progress and spot gaps.

Related Topics

• Introduction to DevOps
• What is DevOps?
• The DevOps lifecycle
• The DevOps toolchain
• Setting up a practice lab