Sefism DevOps and Cloud Roadmap

What this roadmap is

The DevOps and cloud roadmap is Sefism's path for developers and sysadmins who want to own how software gets built, shipped and kept running. It starts on the Linux command line, adds networking and Docker, teaches AWS one service at a time, then moves everything into Terraform and a CI/CD pipeline, runs it on Kubernetes with GitOps, and finishes with observability and incident response.

There is no edition to choose: the roadmap teaches AWS as its cloud and the open source stack (Terraform, GitHub Actions, Kubernetes, Helm, Argo CD, Prometheus, Grafana and OpenTelemetry) around it. The one application you deploy in stage 4 is rebuilt in code in stage 5 and moved to Kubernetes in stage 6, so the stages add up to one system.

What you can do at the end

• Work comfortably on a Linux server over SSH, debug networking problems with dig, curl and ss, and automate routine jobs with Bash.
• Run a three-tier application on AWS using IAM roles, a VPC, EC2 with Auto Scaling, a load balancer, RDS and Route 53.
• Provision that infrastructure with Terraform and deploy to it from a GitHub Actions pipeline without long-lived keys.
• Containerise an application and run it on Kubernetes with Helm and Argo CD.
• Set up metrics, logs, traces and SLO-based alerts, and lead an incident through to a blameless postmortem.

Who it suits, and who should start elsewhere

It suits backend developers who want to deploy and run their own services, sysadmins and support engineers moving into DevOps, and students aiming for a first DevOps or cloud role.

If you have never used a terminal or Git, the Linux, terminal and Git roadmap is a gentler start. If you want to go deeper on cloud architecture across providers, follow this roadmap and then Cloud engineering. If reliability and internal platforms are where you are heading, Platform engineering and SRE continues from stage 7. If you are not yet able to build a small app, Backend development gives you something worth deploying.

Time and pace

The seven stages total about 385 hours. The first stage, Linux, the shell and scripting, is a foundation: if you already live in a terminal, your plan lets you skim or skip it.

A student's week (10 to 12 hours): use Linux as your daily environment (a VM or WSL is fine, as the roadmap suggests), spend two sessions on the stage's course and two hands-on sessions on the running project, and commit everything to Git. Set a billing alarm before you create anything on AWS.

Someone working full time (about 5 hours): one evening of learning and one longer weekend lab. Tear cloud resources down at the end of each session and note what they cost; the cloud stage's milestone asks you to do exactly that.

Stage by stage

1. Linux, the shell and scripting (about 60 hours, foundation)

The filesystem, files and permissions, users, groups and sudo, processes and signals, services with systemd, packages and system logs, pipes, grep, sed and awk, writing Bash scripts, scheduling with cron and systemd timers, SSH keys and remote access, and Git for scripts and configuration.

Milestone: a fresh Ubuntu VM with users and the right permissions, and a cron-scheduled Bash script that backs up a directory and reports disk usage, all in a Git repository.

2. Networking for engineers (about 35 hours)

IP addresses, subnets and CIDR, TCP, UDP and ports, DNS records and resolution, HTTP requests and responses, TLS and certificates, firewalls, Nginx as a reverse proxy and load balancer, and debugging with dig, curl, ss and traceroute.

Milestone: a domain pointed at a cloud VM, an app served behind Nginx with a free TLS certificate, a firewall open only on 22, 80 and 443, and a deliberately broken DNS record debugged with dig.

3. Containers with Docker (about 35 hours)

What a container is, images, containers and the Docker CLI, writing Dockerfiles, layer caching, multi-stage builds and small images, running as non-root and hardening images, volumes, container networking, Docker Compose, and registries, tags and image scanning.

Milestone: a web app and its database containerised with a multi-stage Dockerfile running as non-root, run locally with Docker Compose, and the image pushed to a registry.

4. Cloud on AWS, service by service (about 80 hours)

Ten services in the order real problems appear: regions, availability zones and a safe account, IAM users, roles and policies, EC2 and EBS, security groups, S3, VPC, subnets and route tables, CloudWatch, load balancers and Auto Scaling, RDS and Route 53, and optionally serverless, queues and caches when a problem calls for them. The checklist starts on day one with MFA on the root account and a billing alarm.

Milestone: a three-tier app deployed by hand in your own VPC (EC2 in an Auto Scaling group behind a load balancer, RDS in a private subnet, static files on S3, a Route 53 record and a CloudWatch alarm), then torn down with a note of what it cost.

5. Infrastructure as code and CI/CD (about 50 hours)

Why infrastructure as code, Terraform providers, resources and the plan and apply loop, state, remote state and locking, modules, environments and drift, continuous integration and delivery, GitHub Actions workflows, build, test and deploy stages, secrets and OIDC in pipelines, and config in the environment.

Milestone: your three-tier setup recreated entirely in Terraform with remote state and locking, and a GitHub Actions pipeline that tests, builds and pushes the image, plans on pull requests and applies on merge using OIDC instead of stored keys.

6. Kubernetes and GitOps (about 80 hours)

The stage most DevOps job descriptions are really asking about. Cluster architecture and kubectl, pods, deployments and rolling updates, services and discovery, ConfigMaps and Secrets, liveness, readiness and startup probes, ingress, requests, limits and autoscaling, Helm charts, and GitOps with Argo CD.

Milestone: a multi-service app on a local kind or k3d cluster deployed with Helm, with ingress, resource limits, a horizontal pod autoscaler and a rolling update, synced from Git by Argo CD.

7. Observability and incident response (about 45 hours)

Metrics, logs and traces, Prometheus and PromQL, Grafana dashboards for the golden signals, centralised structured logs, tracing with OpenTelemetry, SLIs, SLOs and error budgets, alerting on symptoms and burn rate, incident roles and response, and blameless postmortems.

Milestone: your app instrumented with Prometheus metrics and OpenTelemetry traces, a golden-signals dashboard and an SLO-based alert; then you break the service on purpose, run the incident as commander and write the postmortem.

Projects to build

Six projects from the Sefism library, starting with the gentlest:

• API contract checker for continuous integration
• Three-tier web app on AWS with infrastructure as code
• Self-hosted CI runner autoscaler
• Distributed tracing for a polyglot microservice system
• Deployment pipeline with progressive rollout and automatic rollback
• Kubernetes resource right-sizing advisor

How it works on Sefism

The public page at /roadmaps/devops-cloud/ shows the full stage list, with the first two stages open to read. Everything on Sefism is free to learn from. A few actions use credits, such as adding a roadmap to your dashboard; new members get starting credits, the first roadmap is free, and if you are learning seriously and run out you can ask for more.

Adding the roadmap opens every stage in the member area. You set your weekly hours and familiarity, tick off topics and stages, and each topic has an explanation, a check question and a prompt that makes an AI assistant quiz you instead of doing the work. Following the roadmap also unlocks its companion cheat sheet. If you are stuck on a stage or unsure whether you are ready to apply, send Tauseef a question or book a 1:1 session.

The companion cheat sheet

The DevOps and cloud cheat sheet covers the same ground in ten chapters, adding Git workflows and security basics as chapters of their own. Use it to refresh a command or concept before you touch a server, a pipeline or a cluster.

Related on Sefism

• Do I need Docker and Kubernetes as a junior developer?
• Which cloud should I learn first: AWS, Azure or GCP?
• How do I practise on AWS, Azure or Google Cloud without a surprise bill?
• Can a fresher get a cloud engineering job?
• Are certifications like AWS or Google Cloud worth it?
• The Cloud Resume Challenge and DevOps with Kubernetes, both used in the stages.

What you can do afterwards

You will have one application that went from a Git repository to a monitored, automatically deployed service on AWS and Kubernetes, with Terraform, a pipeline, dashboards, an alert and a postmortem to show for it. That is the shape of the work junior DevOps and cloud roles do, and a portfolio you can walk someone through.

Frequently asked questions

How long does it take to learn DevOps? This roadmap is about 385 hours: roughly 32 weeks at 12 hours a week, or about a year and a half at 5. Skipping the Linux stage if you already know it saves about 60 hours.

Should I learn Docker or Kubernetes first? Docker first. Stage 3 covers containers, and Kubernetes comes in stage 6, after you have deployed to the cloud and automated it.

Do I need to learn every AWS service? No. The roadmap teaches ten services that are enough to run a real product, and adds Lambda, DynamoDB, SQS and the rest only when a problem calls for one.

Terraform or Ansible? The roadmap teaches Terraform properly and suggests learning configuration tools such as Ansible only as far as your job needs them.