If you're starting DevOps, one of the first problems you'll probably face is figuring out where to start.
There are so many tools people tell you to learn: Linux, Git, Docker, Kubernetes, AWS, Terraform, CI/CD, and a lot more.
Finding tutorials for these tools isn't really the problem. The difficult part is knowing what to learn first and when you're ready to move to the next thing.
I've been learning DevOps myself, and one thing I've noticed is that jumping from one tool to another without a clear order makes everything more confusing.
So I wanted to share the learning path that makes the most sense to me.
1. Linux
I would start with Linux before getting into Docker, Kubernetes, or cloud platforms.
You don't need to know everything about Linux. At the beginning, I think it's more important to get comfortable using the terminal and understand things like:
- Files and directories
- Permissions
- Users and groups
- Processes
- Package management
- SSH
- Basic Bash commands
- Basic networking commands
The goal isn't to become a Linux expert. You just want to reach the point where using the terminal doesn't feel uncomfortable anymore.
2. Networking
Networking is another thing I wouldn't skip.
Once you start working with servers, containers, cloud services, and Kubernetes, you'll constantly run into networking concepts.
I would make sure I understand at least:
- IP addresses
- DNS
- Ports
- TCP/IP
- HTTP and HTTPS
- Subnets
- Firewalls
- Public and private IP addresses
You don't need networking-engineer-level knowledge, but having a good foundation makes the later topics much easier to understand.
3. Git and GitHub
After that, I would spend some time learning Git properly.
The basic commands are important:
git clone
git status
git add
git commit
git push
git pull
git branch
git merge
But I don't think memorizing commands is enough.
Create a repository, make a new branch, change something, commit it, push the branch, open a pull request, and merge it.
Also practice creating and solving a merge conflict at least once.
That helped me understand Git much more than just watching tutorials.
4. Docker
Once Linux and Git start making sense, I would move to Docker.
Start with the basics:
- Images
- Containers
- Dockerfiles
- Volumes
- Networks
- Docker Compose
Then find a simple application and try to containerize it yourself.
Writing your own Dockerfile and fixing the problems you run into teaches you much more than just running commands from a tutorial.
5. CI/CD
After Git and Docker, CI/CD starts making a lot more sense.
GitHub Actions is a good place to start.
Try creating a simple pipeline that runs automatically when you push code.
For example:
- Push code to GitHub
- Run tests
- Build the application
- Build a Docker image
You can make the pipeline more complicated later.
At the beginning, I think understanding why you're automating these steps is more important than building a huge pipeline.
6. Pick one cloud platform
I wouldn't try to learn AWS, Azure, and Google Cloud at the same time.
Pick one and learn the fundamentals.
Focus on things like:
- Virtual machines
- Storage
- Networking
- IAM
- Firewalls or security groups
- Load balancing
- Monitoring
There are hundreds of cloud services, so trying to learn all of them isn't realistic.
I think it's better to understand how a basic application can be hosted in the cloud first.
7. Terraform
Once you understand how to create basic cloud infrastructure manually, Terraform becomes much easier to understand.
Start with:
- Providers
- Resources
- Variables
- Outputs
- State
- Modules
A simple first project could be creating a virtual machine and its network using Terraform instead of creating everything manually.
That makes the purpose of Infrastructure as Code much clearer.
8. Kubernetes
I personally wouldn't start Kubernetes too early.
It can be confusing if you're still trying to understand containers and networking at the same time.
Once you're comfortable with Linux, networking, and Docker, start learning:
- Pods
- Deployments
- Services
- ConfigMaps
- Secrets
- Namespaces
- Ingress
Then take an application you've already containerized and try deploying it to Kubernetes.
9. Monitoring
Another topic that's easy to forget as a beginner is monitoring.
Getting an application running is only part of the job. You also need to know what happens when something goes wrong.
Some things worth learning are:
- Logs
- Metrics
- Alerts
- Prometheus
- Grafana
Even a small monitoring project can teach you a lot about how applications behave after deployment.
10. Build projects
This is probably the part I would focus on the most.
It's easy to spend months watching tutorials and feel like you're making progress, but eventually you need to build things without following someone step by step.
Try connecting the tools you've learned.
For example:
GitHub -> CI/CD -> Docker -> Cloud -> Kubernetes -> Monitoring
It doesn't have to be a huge project.
A smaller project that you actually understand is much better than copying a complicated project from a tutorial.
Also document your projects on GitHub. Explain what you built, what tools you used, what went wrong, and how you fixed it.
The order I would follow
If I had to simplify everything into one learning path, mine would look like this:
Linux -> Networking -> Git/GitHub -> Docker -> CI/CD -> Cloud -> Terraform -> Kubernetes -> Monitoring -> Projects
I'm still learning as well, so I don't look at this as a perfect or universal roadmap.
It's simply the order that has made the most sense to me after spending time learning these tools.
I also put together a more structured DevOps beginner roadmap for anyone who wants the learning path in one place.
You can find it here:
If you're learning DevOps too, I'm curious what you're currently working on and whether you'd change anything in this order.
Top comments (0)