DevOps Training

From zero to interview-ready. No fluff, simple analogies, copy-paste commands, and a hands-on project from start to finish.

Start the course View cheatsheet

Where to start?

10 Modules

From Linux to Kubernetes, a progressive hands-on journey. Get started →

Hands-on Project

A React + FastAPI app that evolves with each module. View project →

Interview Prep

Technical questions, scenarios, system design exercises. Practice →

Cheatsheet

All essential commands in a single file. Browse →

What is DevOps?

In the software world, there are generally three main areas:

Frontend — what the user sees and interacts with: buttons, pages, design. The frontend developer writes code that runs in your browser (or mobile app). Technologies: React, Vue, HTML/CSS, etc.
Backend — what runs on the server, behind the scenes. The heart of the backend is the API: a program that runs 24/7 on a server and receives messages from the frontend. When you open your cart, the frontend sends a message to the API (“give me this user’s cart”), the API fetches the data from the database and sends it back to the frontend which displays it. When you click “Place order”, the frontend sends another message to the API, and it’s the API that processes the request: it checks the cart, charges the card, saves the order in the database, and responds to the frontend “all good, order confirmed”. Technologies: Python, Java, Go, Node.js, etc.
DevOps — everything between the code and the end user. The code is written, OK — but how do we test it automatically? How do we put it online? On which server? How do we know it’s working? How do we handle 10,000 users at once? That’s DevOps.

Concretely, DevOps is the job of building and maintaining the infrastructure that allows code to run in production. You don’t code the application — you make sure it’s delivered, deployed, monitored, and can handle the load.

Why it’s a great choice to get started

In frontend, you’ll often be asked to understand the backend and have a good sense of design/UX. In backend, you’ll be expected to also do basic frontend and sometimes DevOps. These two domains have blurry boundaries — you quickly end up wearing multiple hats.

DevOps is its own domain. In a company, no one will ask you to code frontend features or design pages. Your scope is clear: infrastructure, deployment, automation, monitoring. You can focus on a single domain and become productive quickly.

It’s also a domain with high demand, and the core skills (Linux, Docker, CI/CD, Cloud) can be learned in a few weeks with practice. This course is built for that.

Don’t know the terms below (Docker, Terraform, Kubernetes…)? That’s normal — that’s exactly what this course will teach you, one by one. Start with Module 0 and it will all make sense along the way.

Learning Path

Module 0 (Git + WSL) ─▶ Module 1 (Linux) ─▶ Module 2 (Networking) ─▶ Module 3 (Docker)
                                                                        │
                                             ┌──────────────┬───────────┼──────────────┐
                                             ▼              ▼           ▼              ▼
                                       Module 4        Module 8       Module 9    (all
                                       (CI/CD)         (Monitoring)   (K8s)       subsequent
                                             │         optional    awareness     modules)
                                             ▼
                                       Module 5
                                       (AWS)
                                             │
                                             ▼
                                       Module 6
                                       (Terraform)
                                             │
                                             ▼
                                       Module 7
                                       (Ansible)
                                       optional

The Hands-on Project

A simple Task List: React frontend + FastAPI backend. The app itself is trivial — it’s the infrastructure around it that matters.

We evolve it with each module:

Module 0-1: Clone it, run it locally
Module 3: Dockerize it
Module 4: Add a CI/CD pipeline
Module 5: Deploy it on AWS manually
Module 6: Automate the infra with Terraform
Module 7: Configure the server with Ansible
Module 8: Monitor it with Prometheus + Grafana
Module 9: Orchestrate it with Kubernetes

How long does it take?

If you dedicate about 1 hour every 2 days, you can finish the course in 6 to 8 weeks. It’s not a race — better to go slowly and understand than rush through everything.

How to use this course

Follow the modules in order (each module depends on the previous ones)
Type the commands yourself — don’t just copy-paste without reading
When you’re stuck, check the hints before searching on Google
After each module, do the Interview Corner to check your understanding
The cheatsheet is your quick reference for commands
The interview questions are your final review

A Typical Day as a DevOps Engineer

This question comes up often in interviews: “What does the job actually look like?”

Morning:

Check the dashboards (Grafana, Datadog) — is everything running? Any errors overnight?
Read the alerts received during the night — sort between noise and real problems
Review pull requests — code review, especially infrastructure changes (Terraform, Dockerfiles, CI/CD)

During the day:

Improve the infra — optimize a slow CI/CD pipeline, upgrade a Kubernetes version, migrate a service to a new provider
Help the devs — “my container crashes”, “the deployment doesn’t work”, “how do I configure the env variable in staging?”
Write infrastructure code — Terraform for a new service, an Ansible playbook, a new GitHub Actions workflow
Automate — anything done manually more than twice should be scripted

When things go wrong (incident):

Diagnose: logs, metrics, traces
Fix urgently (rollback, restart, scale up)
Communicate with the team (status page, Slack)
Write a post-mortem after the incident (what happened, how to prevent it from happening again)

Prepare for Your Interview

In DevOps interviews, there are 3 types of questions. Practice them in this order:

Step	Question Type	Resource
1. Definitions	”What is a Docker container?”, “What is Terraform state?”	Interview Questions
2. Experience	”Tell me about a prod incident”, “How do you handle a rollback?”	Experience Questions
3. System design	”How would you deploy this app for 50,000 users?”	System Design Exercises