The complete learning path in reading order: every stage, topic, and what you gain from it. Use the interactive map above to track your progress.
1. The Core Foundation
Don’t get swayed by fancy sides yet. Get your basics right first.
Networking: The absolute base. Understand how data moves.
Research & sub-topics: OSI Model (Layers 3, 4, 7), TCP/UDP protocols, IP Addressing & Subnetting, DNS resolution process, HTTP/HTTPS headers, Load Balancing algorithms (Round Robin, Least Conn), and SSH tunneling.
How to learn it: Learn by using tools like "dig" for DNS, "curl -v" for HTTP headers, and "netstat" or "ss" for socket connections. This teaches you how packets are routed and why a connection might fail at different layers.
Knowledge gained: You will gain the ability to troubleshoot connectivity issues between services, understand latency, and design secure network boundaries.
Operating Systems (Linux): Master the command line and system internals.
Research & sub-topics: File System Hierarchy (FHS), Permissions (Chmod/Chown), Process management (PID, signals, systemd), Package management, Resource monitoring (top/htop/iostat), and Shell Scripting (Bash/Zsh).
How to learn it: Install a headless Linux distro. Try to automate a user creation script or a log rotation cleanup. This teaches you how the hardware talks to the software and how to manage resources efficiently.
Knowledge gained: Proficiency in the environment where 99% of DevOps tools run. You will understand how to optimize system performance and automate repetitive tasks.
Virtualization: Familiarize yourself with how hardware is abstracted.
Research & sub-topics: Hypervisors (KVM, VMware, VirtualBox), Type 1 vs Type 2 virtualization, CPU/RAM overcommitment, Snapshotting, and Vagrant for environment reproducibility.
How to learn it: Use VirtualBox or VMware to spin up multiple Linux nodes. Network them together. This teaches you the concept of "Infrastructure as Software" and hardware abstraction.
Knowledge gained: A deep understanding of how modern cloud providers function under the hood and how to create isolated testing environments.
2. Programming & Dev Basics
Get the knack of coding and how applications are built.
Python: The most popular language for DevOps automation.
Research & sub-topics: Boto3 (AWS SDK), OS and Sys modules, Virtual environments (venv/poetry), JSON/YAML parsing, Error handling, and interacting with REST APIs using the Requests library.
How to learn it: Write a script that monitors a website status and sends an email/alert if it is down. This teaches you how to bridge the gap between manual operations and automated code.
Knowledge gained: The ability to extend tool functionality and automate complex workflows that off-the-shelf tools cannot handle.
App Architecture: Learn the what and how of Frontend, Backend, and Databases.
Research & sub-topics: Stateless vs Stateful applications, RESTful API design, Database indexing, Caching strategies (Redis), and connection pooling.
How to learn it: Build a very simple CRUD app. This teaches you the flow of data and why developers ask for specific configurations (like CORS or specific DB ports).
Knowledge gained: You gain empathy for developers and the technical context needed to build deployment pipelines that actually work for the code being shipped.
Git: Version control is a non-negotiable tool.
Research & sub-topics: Branching strategies (Trunk-based, Gitflow), Merge vs Rebase, Git Hooks, SSH vs HTTPS auth, and Cherry-picking.
How to learn it: Work on a project with multiple branches. Intentionally create a merge conflict and resolve it. This teaches you how teams collaborate on code without stepping on toes.
Knowledge gained: The foundation for "Everything as Code." You will be able to manage infrastructure, configuration, and application code versioning.
3. DevOps Culture
DevOps is a culture at its core, driven to improve Agile SDLC.
Agile SDLC: Understand the software development life cycle.
Research & sub-topics: Scrum vs Kanban, Sprint Planning, Story Points, and the feedback loop. Focus on how "Continuous" (Integration/Deployment) fits into the cycle.
How to learn it: Participate in or simulate a mock sprint. This teaches you how business requirements translate into technical tasks and why speed-to-market matters.
Knowledge gained: Understanding the "Why" behind DevOps. You will know how to align technical work with business goals.
Collaboration: Bridging the gap between Dev and Ops teams.
Research & sub-topics: The CAMS model (Culture, Automation, Measurement, Sharing), Blameless Post-mortems, and Site Reliability Engineering (SRE) principles.
How to learn it: Read case studies on DevOps transformations (e.g., The Phoenix Project). This teaches you that DevOps is 80% people and 20% tools.
Knowledge gained: Soft skills and organizational mindset. You will learn how to break down silos and foster a culture of shared responsibility.
4. Local Deployment
Hands-on: Deploy a basic 3-tier application locally inside a VM.
Web Servers: Setting up and configuring Nginx.
Research & sub-topics: Configuration blocks (events, http, server, location), virtual hosts, static file serving, and Log formats.
How to learn it: Manually install Nginx and host a custom HTML page. This teaches you how a web server listens on ports and serves requests.
Knowledge gained: Core web hosting skills. You will understand how the entry point of most applications works.
Reverse Proxy: Understanding how to route traffic to your app.
Research & sub-topics: Upstream blocks, proxy_set_header, SSL termination (Certbot/Self-signed), and path-based vs domain-based routing.
How to learn it: Configure Nginx to sit in front of a Python/Node process. This teaches you security through abstraction and how to handle application traffic.
Knowledge gained: Understanding how to protect backend servers and manage traffic flow at the edge.
3-Tier Logic: Connecting Web -> App -> Database.
Research & sub-topics: Network isolation between tiers, Connection strings, Environment variables, and basic SQL commands for testing connectivity.
How to learn it: Setup a VM and manually install a DB and an App. Connect them. This teaches you about the complexity of stateful connections and dependencies.
Knowledge gained: Full-stack infrastructure awareness. You will know exactly how all components of a modern web app interact.
5. Containers & Orchestration
Time to master modern packaging and orchestration.
Docker: Universal containerization. Dissect VM vs Container.
Research & sub-topics: Linux Namespaces & Cgroups (the magic behind containers), Dockerfile optimization (Layer caching, Multi-stage builds), and Docker Compose.
How to learn it: Containerize your 3-tier app. Compare the resource usage vs the VM version. This teaches you about efficiency and portability.
Knowledge gained: The ability to "package once, run anywhere." You eliminate the "it works on my machine" problem.
Kubernetes (K8s): Orchestration. Deploy your 3-tier app here.
Research & sub-topics: Control Plane vs Worker Nodes, Declarative YAML (Pods, Deployments, Services, Ingress), and Self-healing (ReplicaSets).
How to learn it: Deploy your app to Minikube. "Kill" a pod and watch K8s recreate it. This teaches you about high availability and automated management.
Knowledge gained: The industry-standard for scaling applications. You will be able to manage large-scale distributed systems.
ArgoCD (Optional): GitOps style CD for your Kubernetes clusters.
Research & sub-topics: The GitOps Manifest, Application Controller, and the concept of "Desired State" vs "Actual State".
How to learn it: Change a tag in your Git repo and watch ArgoCD automatically update your K8s cluster. This teaches you about automated reconciliation.
Knowledge gained: Modern deployment automation. You will learn how to keep environments in sync without manual intervention.
6. The Cloud (AWS)
Apply your knowledge to a major provider like AWS.
AWS Services: VPC, EC2, ECS/EKS, S3, Lambda.
Research & sub-topics: Regions vs Availability Zones, Shared Responsibility Model, IAM (Roles vs Users), and Security Groups.
How to learn it: Set up a custom VPC with public and private subnets. This teaches you how cloud providers virtualize entire data centers.
Knowledge gained: Cloud literacy. You will understand how to build resilient infrastructure using global-scale services.
Cloud Migration: Deploy that same 3-tier app in the cloud.
Research & sub-topics: Managed Services (RDS) vs Self-managed, Application Load Balancers (ALB), and Auto-scaling Groups (ASG).
How to learn it: Migrate your local app tiers to EC2 and RDS. This teaches you about the "Managed Service" trade-off (cost vs effort).
Knowledge gained: Cloud-native engineering skills. You will know how to take an app from a local dev machine to a global production environment.
CI/CD: Implement automation using GitHub Actions.
Research & sub-topics: Workflows, Actions, Runners, Secrets, and Build Matrix.
How to learn it: Create a pipeline that triggers on code push. Build an image and deploy it to AWS. This teaches you the power of "Continuous" delivery.
Knowledge gained: The heart of DevOps productivity. You will be able to automate the path from code to customer.
7. Infrastructure as Code
Automate your infrastructure once you have the hang of the Cloud.
Terraform: The industry standard for declarative infrastructure.
Research & sub-topics: Provider blocks, Resource blocks, State files (.tfstate), Backend configuration (S3/DynamoDB for locking), and Variables.
How to learn it: Define your AWS VPC and EC2 in Terraform files. Run "terraform apply". This teaches you how to treat your hardware like code.
Knowledge gained: The ability to recreate an entire environment in minutes. You eliminate "Configuration Drift" and manual errors.
Pulumi: An alternative using familiar programming languages.
Research & sub-topics: The Pulumi Engine, Automation API, and using standard languages (Python/TS) to loop and create resources.
How to learn it: Try to create 5 S3 buckets using a simple Python "for loop" in Pulumi. This teaches you the power of logic in infrastructure.
Knowledge gained: Infrastructure engineering using developer tools. You will understand the next generation of IaC.
8. Security First
Learn about security once you understand how the systems are built.
OWASP Top 10: Understand web vulnerabilities and mitigation.
Research & sub-topics: SQL Injection, Broken Access Control, Security Misconfiguration, and Vulnerable Components.
How to learn it: Read about common exploits. Look at how Nginx ModSecurity or AWS WAF can block these. This teaches you defensive system design.
Knowledge gained: A security-first mindset. You will know how to build systems that are hardened by default.
Web App Security: Learn how to secure the application layer.
Research & sub-topics: Content Security Policy (CSP), HSTS headers, Secrets Management (preventing passwords in Git), and OAuth2/OIDC basics.
How to learn it: Use a tool like Snyk or Trivy to scan your Docker images for vulnerabilities. This teaches you that secure code includes the base image.
Knowledge gained: Technical security competence. You will be able to protect user data and business secrets.
Security Culture: Shifting security left in the pipeline.
Research & sub-topics: DevSecOps integration, automated compliance checks, and Principle of Least Privilege (PoLP).
How to learn it: Apply strict IAM policies that only allow a user to do one specific task. This teaches you about the "blast radius" of security breaches.
Knowledge gained: Strategic security awareness. You will learn how to make security a part of the development speed, not a bottleneck.
9. System Architecture
The final step: Learn types of system architecture and design based on needs.
Decision Framework: How to select the right service or technology stack.
Research & sub-topics: CAP Theorem, Microservices vs Monolith, Serverless vs Fixed clusters, and when to use NoSQL vs SQL.
How to learn it: Analyze a project requirement. Choose a stack and justify it. This teaches you that there is no "best" tool, only the "right" tool for the job.
Knowledge gained: High-level engineering leadership. You will be able to lead technical discussions and choose long-term strategies.
Cost Optimization: Designing for budget efficiency and ROI.
Research & sub-topics: AWS Cost Explorer, Right-sizing (Compute Optimizer), Spot Instances, and Cloud Carbon Footprint.
How to learn it: Compare the monthly cost of an RDS instance vs running a DB on EC2. This teaches you the financial impact of architectural choices.
Knowledge gained: FinOps literacy. You will learn to build systems that are not just technically sound but also financially sustainable.
Availability & Reliability: Implementing HA and fault-tolerant designs.
Research & sub-topics: SLA vs SLO vs SLI, RTO/RPO (Recovery Time/Point Objective), and Blue-Green vs Canary deployments.
How to learn it: Design a system that stays online even if a whole AWS Data Center goes down. This teaches you about "Design for Failure."
Knowledge gained: Reliability engineering. You will know how to build systems that users can trust 24/7.
Security & Compliance: Ensuring the architecture meets regulatory needs.
Research & sub-topics: SOC2, GDPR, HIPAA basics (as they relate to infra), Data residency, and Encryption at Rest vs Transit.
How to learn it: Look at how to audit a system. This teaches you that your architecture must be verifiable and defensible.
Knowledge gained: Governance and professional ethics. You will understand how to build systems that are legal and compliant.
10. GenAI for DevOps
AI is not replacing DevOps engineers. DevOps engineers who use AI are replacing those who don’t.
Prompt Engineering: Learn to talk to LLMs effectively for technical tasks.
Research & sub-topics: Zero-shot vs Few-shot prompting, Chain-of-Thought, System prompts, Temperature and token limits, and context window management.
How to learn it: Give an LLM a vague prompt, then a precise one, and compare outputs. This teaches you that AI quality depends entirely on how you ask.
Knowledge gained: The core skill of the AI age. You will be able to extract reliable, actionable output from any LLM for infrastructure and automation tasks.
LLM APIs & SDKs: Call AI models programmatically from Python.
Research & sub-topics: OpenAI API, AWS Bedrock, LangChain basics, structured output (JSON mode), and streaming responses.
How to learn it: Write a Python script that takes a task description and returns a Terraform snippet via an LLM API. This teaches you how to embed AI into your automation workflows.
Knowledge gained: The ability to build custom AI-powered DevOps tools — from config generators to intelligent alerting systems.
AI-Assisted IaC & Config: Use AI to generate, review, and optimize infrastructure code.
Research & sub-topics: AI pair programming (Copilot/Kiro), generating HCL/YAML from natural language, AI-powered code review bots, and drift detection.
How to learn it: Describe an AWS architecture in plain English and use AI to generate the Terraform. Then review and fix what it got wrong. This teaches you to use AI as a force multiplier, not a crutch.
Knowledge gained: 10x productivity in writing infrastructure code. You will ship faster while still understanding every line.
Responsible AI in Ops: AI hallucinations can take down production. Learn the guardrails.
Research & sub-topics: Hallucination detection, output validation, human-in-the-loop patterns, cost of LLM API calls, and when NOT to use AI (secrets, compliance decisions).
How to learn it: Intentionally ask AI to generate a security group rule and verify if it is actually secure. This teaches you that AI output must always be validated before applying to production.
Knowledge gained: Critical thinking in the AI era. You will know how to leverage AI speed without sacrificing reliability or security.