How I'd learn DevOps if I started today

People often ask me how to get into DevOps. The internet's answer is usually a giant roadmap diagram with a hundred boxes: every tool, every cloud, every buzzword. It's overwhelming, and it suggests you need to learn everything before you can do anything.

You don't. Here's the path I'd take if I started from zero today: in order, with one practical project per stage, and honest time estimates.

The order that makes sense

The order matters because each step builds on the last. Kubernetes makes very little sense if you don't understand Linux, networking and containers first.

1. Linux and the command line (4–6 weeks)

Everything in DevOps runs on Linux. Learn to live in the terminal: files and permissions, processes, services with systemd, package management, logs, SSH, basic shell scripting.

Project: set up a Linux VM (or a cheap cloud server), harden SSH, install NGINX, serve a static page, and write a small Bash script that backs up its config every night with cron.

2. Networking fundamentals (2–3 weeks, alongside Linux)

IP addresses and subnets, DNS, TCP vs UDP, ports, HTTP, TLS, load balancers, firewalls. This is the knowledge that makes debugging possible later.

Project: point a real domain at your server, get a free TLS certificate with Let's Encrypt, and debug it with dig, curl -v and ss.

3. Git (1–2 weeks)

Branches, merges, rebases, pull requests, resolving conflicts. Everything in DevOps lives in Git, including infrastructure.

Project: put your server's config and scripts in a GitHub repository, and work through pull requests even if you're alone.

4. A programming language (ongoing, start now)

Python is the easiest start for automation. Later, Go is valuable for cloud-native tooling. You don't need to become a software engineer, but you need to read and write real code.

Project: a Python script that checks your website's status and certificate expiry, and sends you a message if something is wrong.

Don't try to learn the whole roadmap. Learn the next step well enough to build something, then take the next one.

5. Containers (3–4 weeks)

Docker or Podman: images, Dockerfiles, multi-stage builds, volumes, networks, Docker Compose. Understand what a container really is (a Linux process with namespaces and cgroups).

Project: containerise a small web app with a database, using Docker Compose, with a small, secure image.

6. CI/CD (2–3 weeks)

Pipelines that test, build, scan and deploy automatically. GitHub Actions is the easiest place to start.

Project: a pipeline that runs tests, builds your container image, scans it with Trivy, pushes it to a registry, and deploys it to your server.

7. A cloud provider (6–8 weeks)

Pick one: AWS, Azure or Google Cloud, whichever is most common in the jobs you want. Learn the core: identity and access (IAM), networking (VPCs, subnets, security groups), compute, storage, managed databases, and cost basics.

Project: deploy your app to the cloud with a managed database, in a private network, behind a load balancer. Set up a budget alert first.

8. Infrastructure as code (3–4 weeks)

Terraform or OpenTofu. Resources, variables, modules, state, plans. Never click in the console again for anything you want to keep.

Project: rebuild everything from step 7 in Terraform, delete it, and recreate it with one command.

9. Kubernetes (6–10 weeks)

Now Kubernetes will make sense. Pods, deployments, services, configmaps, secrets, ingress or Gateway API, Helm, resource requests, debugging.

Project: run your app on a local cluster (kind or k3s), then on a managed cluster, deployed with Helm and GitOps (Argo CD or Flux).

10. Observability (3–4 weeks)

Metrics, logs and traces. Prometheus, Grafana, Loki, OpenTelemetry. Alerts that make sense.

Project: add a dashboard and two meaningful alerts for your app, and instrument it with OpenTelemetry.

11. Security throughout

Not a separate step, but woven into every step: least privilege, secrets management, image scanning, network policies, keeping things patched.

Resources I trust

• Official documentation: Kubernetes, Terraform, your cloud provider. Better than most courses.
• KodeKloud and A Cloud Guru / Pluralsight for hands-on labs.
• "The Phoenix Project" and "The DevOps Handbook" for the culture and the why.
• Google's SRE books (free online) for reliability.
• roadmap.sh/devops as a map, not a checklist.
• Killercoda and iximiuz Labs for free browser-based practice environments.
• And AI assistants as patient tutors: ask them to explain, not just to write things for you.

How long it really takes

Studying part-time (around 10 hours per week), getting to a junior-ready level takes roughly 9 to 15 months. Faster if you study full-time or already work in IT. It's a marathon, not a sprint, and that's fine.

Things that make it faster:

• Build, don't just watch. One finished project teaches more than ten courses.
• Break things and fix them. Debugging is the real skill.
• Write about what you learn, on a blog or GitHub. It helps you think clearly, and it shows employers what you can do.
• Find people: local meetups, online communities, a study buddy.

What about AI?

AI tools can write a lot of configuration for you now. That makes fundamentals more important, not less: you need to judge whether what the AI wrote is correct and safe. Use AI to learn faster, but make sure you understand everything you ship.

So, where should you start?

Today: install Linux in a VM, open a terminal, and set up that first web server. Everything else follows from there.

My take: DevOps isn't a list of tools. It's understanding how software gets built, shipped and kept running. Learn the foundations in order, build at every step, and the tools become easy.

— Desly