Black Friday SaleIT 360 Bundle complimentary with every master programSee the offer

DevOps

A practical DevOps engineer roadmap: skills, projects and a readiness checklist

Follow a DevOps learning path from Linux and Git to containers and pipelines, with a local Docker project, failed checks, rollback steps and checklist.

By Network Kings · Published 1 April 2024

In this article

What should you learn to become a DevOps engineer? Follow the journey of a change to a running service: Linux and networking, Git and scripting, containers, automated checks, deployment, infrastructure as code and observability. Choose one tool per stage and demonstrate a task before adding another. Start with a small local project that you can build, diagnose and roll back.

This DevOps engineer roadmap is for learners, IT support professionals and system administrators planning their next skills. It focuses on evidence of understanding, rather than a deadline for getting a job. A certification is optional for the exercises below, and completing a course does not replace the vendor's certification process.

A Git change moves through tests, image build, lab deployment and observation; feedback improves the next change and rollback restores a previous image version.
Practise the complete change cycle, including failure and recovery. Open the full-size diagram.

A DevOps roadmap with evidence at every stage

Learn the system before automating it. If you cannot explain why a service is unreachable, a pipeline will only reproduce the problem faster. Use this sequence as a flexible plan: experienced administrators can demonstrate the foundations and spend more time on unfamiliar stages.

Skills to learn and tasks that demonstrate them
StagePractiseEvidence to keep
Linux and networkingProcesses, permissions, listening ports, DNS and HTTPA short investigation of an unreachable service
Git and scriptingCommits, branches, reviewable changes and exit codesA versioned README and a failing health check
ContainersImages, containers, port publication and logsA Dockerfile and reproducible run instructions
Continuous integrationAutomated checks and build artifactsA pipeline definition and a failed run explained
Deployment and recoveryRelease identifiers, smoke tests and rollbackTwo image versions and recovery results
Infrastructure and operationsTerraform plans, access controls, logs and metricsSanitized change review and an incident note

Start one local project and improve it

Exercise status: The following commands were checked against vendor documentation but were not executed with Docker for this article. Test them in your own authorized lab, record the Docker version and keep the output. This exercise uses a local container and requires no public cloud account.

You need a working Docker installation, a terminal with a POSIX shell, Git, curl and a text editor. Docker Desktop or an appropriately configured Docker Engine environment is suitable. Windows learners can use a suitable Linux shell environment; these shell snippets are not PowerShell syntax. Check that local port 8080 and container name roadmap-site are available. If that name already belongs to another container, choose a different lab name throughout these commands instead of removing the existing container.

1. Create and build version one

In a new project directory, create index.html:

<!doctype html>
<html lang="en">
<meta charset="utf-8">
<title>Roadmap lab</title>
<h1>Release v1</h1>
</html>

Create a file named Dockerfile:

FROM nginx:stable-alpine
COPY index.html /usr/share/nginx/html/index.html

Version these files with Git, then build and run the image:

git init
git add index.html Dockerfile
git commit -m "Add version one of local site"
docker build -t roadmap-site:v1 .
docker run --name roadmap-site -d -p 127.0.0.1:8080:80 roadmap-site:v1
curl --fail http://127.0.0.1:8080/
docker logs --tail 20 roadmap-site

If Git asks for your identity, configure it using the identity you intend to associate with this lab. Wait briefly and retry curl if the service is still starting. Expect HTML containing Release v1; a successful container start alone does not prove the application responds.

The port mapping forwards local host port 8080 to container port 80. Binding to 127.0.0.1 keeps this exercise local. Docker otherwise publishes to all host interfaces by default. An EXPOSE instruction alone does not publish a port. See Docker's port-publication guide and container logs reference.

2. Write a check that can fail

Create smoke.sh. It checks both the HTTP response and the exact release heading. The timeout prevents a stalled request from hanging the check; see curl’s official option reference for --fail, --connect-timeout and --max-time:

#!/bin/sh
set -eu
if [ "$#" -ne 1 ] || [ -z "$1" ]; then
  echo 'Usage: ./smoke.sh "Release v1"' >&2
  exit 2
fi
body="$(curl --fail --silent --show-error --connect-timeout 3 \
  --max-time 10 http://127.0.0.1:8080/)"
printf '%s\n' "$body" | grep -Fq -- "<h1>$1</h1>"
chmod +x smoke.sh
./smoke.sh 'Release v1'
if ./smoke.sh 'Release v2'; then
  echo 'Unexpected pass: inspect the check.'
else
  echo 'Expected failure: v2 is not deployed.'
fi

The first check should return zero. The deliberately mismatched heading should fail; Release v10 will not accidentally satisfy a v1 check. HTTP errors, request failures and timeouts also return a failure. The conditional above lets you inspect an expected failure; an automated release gate should execute the check directly and stop when it fails. Do not hide failures with || true in a gate intended to block promotion. This is a smoke test, not a substitute for application unit or integration tests.

3. Deploy version two, then practise rollback

Change the heading in index.html to Release v2. Commit the change and build a separate image tag. Stop and remove only this exercise's named container:

git add index.html smoke.sh
git commit -m "Add version two and smoke check"
docker build -t roadmap-site:v2 .
docker stop roadmap-site
docker rm roadmap-site
docker run --name roadmap-site -d -p 127.0.0.1:8080:80 roadmap-site:v2
./smoke.sh 'Release v2'

Retry the check after startup if necessary. Now restore the existing v1 image:

docker stop roadmap-site
docker rm roadmap-site
docker run --name roadmap-site -d -p 127.0.0.1:8080:80 roadmap-site:v1
./smoke.sh 'Release v1'

This replaces a local container and causes a brief interruption; it is a learning exercise, not a zero-downtime production strategy. Record the Git revision, image tag, test result and time for each release. Tags can be reassigned, and upstream base tags can change; advanced work should record image digests and update pinned dependencies deliberately. Docker's build guidance explains the reproducibility tradeoffs.

4. Diagnose before cleaning up

If the page is unavailable, inspect docker ps -a, the port mapping and container logs. Distinguish a stopped container, a port conflict and a wrong release marker. Write the symptom, evidence, cause and fix in your README.

docker stop roadmap-site
docker rm roadmap-site
docker image rm roadmap-site:v1 roadmap-site:v2

These cleanup commands target the named lab resources. Avoid broad prune commands on a shared Docker host.

Add automation after you understand the manual steps

Choose one CI tool, such as Jenkins. Keep its pipeline definition with the application and arrange checks so a failed candidate does not advance. A useful sequence is validate, build, test in an isolated environment, deploy to the lab and smoke-test. The runner needs the required software and explicitly authorized access; a Jenkins controller does not automatically provide a safe Docker build environment. Jenkins documents source-controlled pipelines and shell-step failure behavior.

Then add infrastructure as code. Read a small Terraform plan and explain what it proposes before applying anything. A plan does not itself carry out the changes. Keep credentials, state and sensitive plan data out of public portfolios. For cloud practice, set a budget and document resource cleanup.

Study Kubernetes after you can explain container behavior. Its official beginner exercises cover deployment, scaling, updates and debugging. Pair that practice with useful logs, metrics and a recovery runbook; installing a cluster alone is not evidence that you can operate an application.

Your DevOps practice checklist

  • Explain the service process, listening port and relevant logs.
  • Rebuild the project from its README and identify the Git revision.
  • Explain image, container, host port and container port.
  • Run the release-heading check and demonstrate a deliberate failure.
  • Deploy v2, restore v1 and record both smoke-test results.
  • Explain where a failed automated check stops promotion.
  • Keep secrets and sensitive infrastructure output out of the repository.
  • Document a fault investigation and remove the lab resources.

Download the DevOps practice checklist. The complete checklist is also readable above.

Choose your next study step

Use the checklist to choose the next gap. For guided learning, compare the DevOps Master Program syllabus, the Docker and Kubernetes course and the practice lab environments. If secure delivery is your focus, explore the DevSecOps program. Confirm current inclusions and lab access before enrolling. Ask for career guidance when you need help sequencing your study; this roadmap does not promise a role, salary or fixed completion time.

Compare current learning plans or request career guidance for your starting point.

Sources and editorial notes

Sources checked on 16 October 2026. Editorial revision prepared with AI assistance; no independent technical review recorded.

Why learn from the top 1% of engineers?

Because passing an exam and doing the job are different skills, and only experience closes the gap. Network Kings mentors have spent 11 to 20+ years building and running networks, cloud platforms and pipelines at companies like Apple, Juniper Networks, IBM and CDAC. They teach what breaks in production, why, and how engineers fix it under pressure.

  • Atul Sharma, Founder & CEO mentor at Network KingsAtul Sharma, Founder & CEO
  • Lazaro (Laz) Diaz, Networking mentor at Network KingsLazaro (Laz) Diaz, Networking
  • Sanjay Sharma, AWS mentor at Network KingsSanjay Sharma, AWS
  • Vikas Kumar, Azure mentor at Network KingsVikas Kumar, Azure
  • Ajay, Azure mentor at Network KingsAjay, Azure
  • Amit Bhatt, Linux & DevOps mentor at Network KingsAmit Bhatt, Linux & DevOps

Atul Sharma (Founder & CEO, 12+ yrs), Lazaro (Networking), Sanjay Sharma (AWS, 20+ yrs) and more. Meet the mentors

Same problem, two answers. Pick a track:

On the job: Two routers' OSPF neighbours are stuck in ExStart and never reach Full.

The textbook answer

OSPF moves through Down, Init, 2-Way, ExStart, Exchange, Loading and Full. Memorise the neighbour states for the exam.

Correct. Not enough to fix it.

How a production engineer teaches it

  1. Suspect an MTU mismatch first. ExStart and Exchange stalls usually come down to it.
  2. Compare show ip ospf interface on both ends and fix the interface MTU.
  3. Use ip ospf mtu-ignore only as a stopgap, and say so in the change record.
  4. Write down why it happened, so the next engineer finds it in minutes.
  • The why behind every command, not just the syntax.
  • Hands-on labs for every topic, so the first fault you fix is not at work.
  • Doubts answered by someone who has fixed it in a live network, cloud or pipeline.