Skip to content
ZK’s OpsPathAll roadmaps
LEARNING ROADMAP

DevOps Engineer

Learn Linux, Git, containers, delivery pipelines, infrastructure automation, and the feedback loops behind dependable operations.

beginner 90 hours 28 milestones
WHAT YOU’LL LEARN
01

Systems and delivery

Build fluency in the tools beneath modern platforms.

Operator foundations

Linux, networking, source control, and scripting.

01

Navigate Linux confidently

60 min · beginner

Manage processes, permissions, filesystems, and services.

Open notes and cheat sheet

Navigate Linux confidently: Manage processes, permissions, filesystems, and services. Practice this in a small lab, record one failure mode, and explain the operational trade-off.

GOAL: Navigate Linux confidently

1. Define the concept
2. Practice with a small example
3. Verify expected behavior
4. Record a failure mode and recovery step
5. Explain the trade-off
02

Explain practical networking

90 min · beginner

Trace DNS, TCP, TLS, proxies, and HTTP requests.

Open notes and cheat sheet

Explain practical networking: Trace DNS, TCP, TLS, proxies, and HTTP requests. Practice this in a small lab, record one failure mode, and explain the operational trade-off.

GOAL: Explain practical networking

1. Define the concept
2. Practice with a small example
3. Verify expected behavior
4. Record a failure mode and recovery step
5. Explain the trade-off
03

Automate a repeatable task

120 min · intermediate

Write a safe shell automation with useful failure output.

Open notes and cheat sheet

Automate a repeatable task: Write a safe shell automation with useful failure output. Practice this in a small lab, record one failure mode, and explain the operational trade-off.

GOAL: Automate a repeatable task

1. Define the concept
2. Practice with a small example
3. Verify expected behavior
4. Record a failure mode and recovery step
5. Explain the trade-off
02

Platform automation

Turn repeatable practices into a delivery system.

Containers and CI/CD

Package, test, release, and observe software.

01

Build a secure container

60 min · beginner

Create a minimal, non-root, multi-stage image.

Open notes and cheat sheet

Build a secure container: Create a minimal, non-root, multi-stage image. Practice this in a small lab, record one failure mode, and explain the operational trade-off.

GOAL: Build a secure container

1. Define the concept
2. Practice with a small example
3. Verify expected behavior
4. Record a failure mode and recovery step
5. Explain the trade-off
02

Design a quality pipeline

90 min · beginner

Gate delivery with tests, scans, and immutable artifacts.

Open notes and cheat sheet

Design a quality pipeline: Gate delivery with tests, scans, and immutable artifacts. Practice this in a small lab, record one failure mode, and explain the operational trade-off.

GOAL: Design a quality pipeline

1. Define the concept
2. Practice with a small example
3. Verify expected behavior
4. Record a failure mode and recovery step
5. Explain the trade-off
03

Operate with feedback

120 min · intermediate

Connect telemetry, SLOs, alerts, and incident learning.

Open notes and cheat sheet

Operate with feedback: Connect telemetry, SLOs, alerts, and incident learning. Practice this in a small lab, record one failure mode, and explain the operational trade-off.

GOAL: Operate with feedback

1. Define the concept
2. Practice with a small example
3. Verify expected behavior
4. Record a failure mode and recovery step
5. Explain the trade-off
03

DevOps Engineer Foundations: Foundations

Chapter group 1: foundations for DevOps Engineer Foundations.

DevOps Engineer Foundations course chapters

Follow each tutorial in order and complete its practical checkpoint.

01

Linux operator essentials

90 min · beginner

Navigate filesystems, permissions, processes, services, and logs confidently.

Open notes and cheat sheet

# Linux operator essentials ## Outcome By the end of this chapter you can explain and apply the core ideas in a small, testable lab. ## Explanation Navigate filesystems, permissions, processes, services, and logs confidently. Connect the concept to the user, operator, and failure-mode impact. Start with the smallest working example, then add validation, observability, and recovery. ## Tools Linux, Bash ## Guided lab 1. Write down the input, expected behavior, and measurable success condition. 2. Build the smallest example and run it locally. 3. Introduce one realistic failure or invalid input. 4. Observe the result, fix the issue, and document the trade-off. ## Architecture ```mermaid flowchart LR User[User or operator] --> App[DevOps Engineer Foundations] App --> Control[Linux] Control --> Signal[Logs, metrics, tests] Signal --> Decision[Verify, recover, improve] ``` ## Checkpoint Explain the concept in your own words, show the lab result, and name one production risk before marking this tutorial complete.

GOAL: Linux operator essentials
TOOLS: Linux, Bash

CHECKLIST
[ ] Define the inputs and success signal
[ ] Build the smallest working example
[ ] Validate failures and unsafe input
[ ] Add a log, metric, or test
[ ] Document rollback or recovery
[ ] Explain one trade-off
02

Shell scripting safely

90 min · beginner

Write scripts with strict mode, input checks, exit codes, and useful output.

Open notes and cheat sheet

# Shell scripting safely ## Outcome By the end of this chapter you can explain and apply the core ideas in a small, testable lab. ## Explanation Write scripts with strict mode, input checks, exit codes, and useful output. Connect the concept to the user, operator, and failure-mode impact. Start with the smallest working example, then add validation, observability, and recovery. ## Tools Bash, shellcheck ## Guided lab 1. Write down the input, expected behavior, and measurable success condition. 2. Build the smallest example and run it locally. 3. Introduce one realistic failure or invalid input. 4. Observe the result, fix the issue, and document the trade-off. ## Architecture ```mermaid flowchart LR User[User or operator] --> App[DevOps Engineer Foundations] App --> Control[Bash] Control --> Signal[Logs, metrics, tests] Signal --> Decision[Verify, recover, improve] ``` ## Checkpoint Explain the concept in your own words, show the lab result, and name one production risk before marking this tutorial complete.

04

DevOps Engineer Foundations: Core practice

Chapter group 2: core practice for DevOps Engineer Foundations.

DevOps Engineer Foundations course chapters

Follow each tutorial in order and complete its practical checkpoint.

01

Secure Dockerfiles

90 min · intermediate

Use multi-stage builds, non-root users, minimal images, and health checks.

Open notes and cheat sheet

# Secure Dockerfiles ## Outcome By the end of this chapter you can explain and apply the core ideas in a small, testable lab. ## Explanation Use multi-stage builds, non-root users, minimal images, and health checks. Connect the concept to the user, operator, and failure-mode impact. Start with the smallest working example, then add validation, observability, and recovery. ## Tools Docker, Trivy ## Guided lab 1. Write down the input, expected behavior, and measurable success condition. 2. Build the smallest example and run it locally. 3. Introduce one realistic failure or invalid input. 4. Observe the result, fix the issue, and document the trade-off. ## Architecture ```mermaid flowchart LR User[User or operator] --> App[DevOps Engineer Foundations] App --> Control[Docker] Control --> Signal[Logs, metrics, tests] Signal --> Decision[Verify, recover, improve] ``` ## Checkpoint Explain the concept in your own words, show the lab result, and name one production risk before marking this tutorial complete.

GOAL: Secure Dockerfiles
TOOLS: Docker, Trivy

CHECKLIST
[ ] Define the inputs and success signal
[ ] Build the smallest working example
[ ] Validate failures and unsafe input
[ ] Add a log, metric, or test
[ ] Document rollback or recovery
[ ] Explain one trade-off
02

Compose local systems

90 min · intermediate

Run an application with databases, networks, volumes, and reproducible config.

Open notes and cheat sheet

# Compose local systems ## Outcome By the end of this chapter you can explain and apply the core ideas in a small, testable lab. ## Explanation Run an application with databases, networks, volumes, and reproducible config. Connect the concept to the user, operator, and failure-mode impact. Start with the smallest working example, then add validation, observability, and recovery. ## Tools Docker Compose ## Guided lab 1. Write down the input, expected behavior, and measurable success condition. 2. Build the smallest example and run it locally. 3. Introduce one realistic failure or invalid input. 4. Observe the result, fix the issue, and document the trade-off. ## Architecture ```mermaid flowchart LR User[User or operator] --> App[DevOps Engineer Foundations] App --> Control[Docker Compose] Control --> Signal[Logs, metrics, tests] Signal --> Decision[Verify, recover, improve] ``` ## Checkpoint Explain the concept in your own words, show the lab result, and name one production risk before marking this tutorial complete.

05

DevOps Engineer Foundations: Production systems

Chapter group 3: production systems for DevOps Engineer Foundations.

DevOps Engineer Foundations course chapters

Follow each tutorial in order and complete its practical checkpoint.

01

Cloud foundations

90 min · intermediate

Understand regions, identity, networking, compute, storage, and shared responsibility.

Open notes and cheat sheet

# Cloud foundations ## Outcome By the end of this chapter you can explain and apply the core ideas in a small, testable lab. ## Explanation Understand regions, identity, networking, compute, storage, and shared responsibility. Connect the concept to the user, operator, and failure-mode impact. Start with the smallest working example, then add validation, observability, and recovery. ## Tools AWS, IAM ## Guided lab 1. Write down the input, expected behavior, and measurable success condition. 2. Build the smallest example and run it locally. 3. Introduce one realistic failure or invalid input. 4. Observe the result, fix the issue, and document the trade-off. ## Architecture ```mermaid flowchart LR User[User or operator] --> App[DevOps Engineer Foundations] App --> Control[AWS] Control --> Signal[Logs, metrics, tests] Signal --> Decision[Verify, recover, improve] ``` ## Checkpoint Explain the concept in your own words, show the lab result, and name one production risk before marking this tutorial complete.

GOAL: Cloud foundations
TOOLS: AWS, IAM

CHECKLIST
[ ] Define the inputs and success signal
[ ] Build the smallest working example
[ ] Validate failures and unsafe input
[ ] Add a log, metric, or test
[ ] Document rollback or recovery
[ ] Explain one trade-off
02

Secrets and configuration

90 min · intermediate

Keep credentials out of code and inject validated runtime configuration.

Open notes and cheat sheet

# Secrets and configuration ## Outcome By the end of this chapter you can explain and apply the core ideas in a small, testable lab. ## Explanation Keep credentials out of code and inject validated runtime configuration. Connect the concept to the user, operator, and failure-mode impact. Start with the smallest working example, then add validation, observability, and recovery. ## Tools AWS Secrets Manager, env ## Guided lab 1. Write down the input, expected behavior, and measurable success condition. 2. Build the smallest example and run it locally. 3. Introduce one realistic failure or invalid input. 4. Observe the result, fix the issue, and document the trade-off. ## Architecture ```mermaid flowchart LR User[User or operator] --> App[DevOps Engineer Foundations] App --> Control[AWS Secrets Manager] Control --> Signal[Logs, metrics, tests] Signal --> Decision[Verify, recover, improve] ``` ## Checkpoint Explain the concept in your own words, show the lab result, and name one production risk before marking this tutorial complete.

06

DevOps Engineer Foundations: Operations and architecture

Chapter group 4: operations and architecture for DevOps Engineer Foundations.

DevOps Engineer Foundations course chapters

Follow each tutorial in order and complete its practical checkpoint.

01

Incident response

90 min · advanced

Detect, triage, communicate, mitigate, and learn from production incidents.

Open notes and cheat sheet

# Incident response ## Outcome By the end of this chapter you can explain and apply the core ideas in a small, testable lab. ## Explanation Detect, triage, communicate, mitigate, and learn from production incidents. Connect the concept to the user, operator, and failure-mode impact. Start with the smallest working example, then add validation, observability, and recovery. ## Tools PagerDuty, runbooks ## Guided lab 1. Write down the input, expected behavior, and measurable success condition. 2. Build the smallest example and run it locally. 3. Introduce one realistic failure or invalid input. 4. Observe the result, fix the issue, and document the trade-off. ## Architecture ```mermaid flowchart LR User[User or operator] --> App[DevOps Engineer Foundations] App --> Control[PagerDuty] Control --> Signal[Logs, metrics, tests] Signal --> Decision[Verify, recover, improve] ``` ## Checkpoint Explain the concept in your own words, show the lab result, and name one production risk before marking this tutorial complete.

GOAL: Incident response
TOOLS: PagerDuty, runbooks

CHECKLIST
[ ] Define the inputs and success signal
[ ] Build the smallest working example
[ ] Validate failures and unsafe input
[ ] Add a log, metric, or test
[ ] Document rollback or recovery
[ ] Explain one trade-off
02

Supply-chain security

90 min · advanced

Pin dependencies, sign artifacts, scan images, and reduce build trust risk.

Open notes and cheat sheet

# Supply-chain security ## Outcome By the end of this chapter you can explain and apply the core ideas in a small, testable lab. ## Explanation Pin dependencies, sign artifacts, scan images, and reduce build trust risk. Connect the concept to the user, operator, and failure-mode impact. Start with the smallest working example, then add validation, observability, and recovery. ## Tools SLSA, SBOM, Cosign ## Guided lab 1. Write down the input, expected behavior, and measurable success condition. 2. Build the smallest example and run it locally. 3. Introduce one realistic failure or invalid input. 4. Observe the result, fix the issue, and document the trade-off. ## Architecture ```mermaid flowchart LR User[User or operator] --> App[DevOps Engineer Foundations] App --> Control[SLSA] Control --> Signal[Logs, metrics, tests] Signal --> Decision[Verify, recover, improve] ``` ## Checkpoint Explain the concept in your own words, show the lab result, and name one production risk before marking this tutorial complete.

GOAL: Shell scripting safely
TOOLS: Bash, shellcheck

CHECKLIST
[ ] Define the inputs and success signal
[ ] Build the smallest working example
[ ] Validate failures and unsafe input
[ ] Add a log, metric, or test
[ ] Document rollback or recovery
[ ] Explain one trade-off
03

Networking fundamentals

90 min · beginner

Trace DNS, TCP, TLS, HTTP, ports, routing, and common failure modes.

Open notes and cheat sheet

# Networking fundamentals ## Outcome By the end of this chapter you can explain and apply the core ideas in a small, testable lab. ## Explanation Trace DNS, TCP, TLS, HTTP, ports, routing, and common failure modes. Connect the concept to the user, operator, and failure-mode impact. Start with the smallest working example, then add validation, observability, and recovery. ## Tools dig, curl, tcpdump ## Guided lab 1. Write down the input, expected behavior, and measurable success condition. 2. Build the smallest example and run it locally. 3. Introduce one realistic failure or invalid input. 4. Observe the result, fix the issue, and document the trade-off. ## Architecture ```mermaid flowchart LR User[User or operator] --> App[DevOps Engineer Foundations] App --> Control[dig] Control --> Signal[Logs, metrics, tests] Signal --> Decision[Verify, recover, improve] ``` ## Checkpoint Explain the concept in your own words, show the lab result, and name one production risk before marking this tutorial complete.

GOAL: Networking fundamentals
TOOLS: dig, curl, tcpdump

CHECKLIST
[ ] Define the inputs and success signal
[ ] Build the smallest working example
[ ] Validate failures and unsafe input
[ ] Add a log, metric, or test
[ ] Document rollback or recovery
[ ] Explain one trade-off
04

Git delivery workflows

90 min · beginner

Use trunk-based development, branching, reviews, tags, and rollback commits.

Open notes and cheat sheet

# Git delivery workflows ## Outcome By the end of this chapter you can explain and apply the core ideas in a small, testable lab. ## Explanation Use trunk-based development, branching, reviews, tags, and rollback commits. Connect the concept to the user, operator, and failure-mode impact. Start with the smallest working example, then add validation, observability, and recovery. ## Tools Git, GitHub ## Guided lab 1. Write down the input, expected behavior, and measurable success condition. 2. Build the smallest example and run it locally. 3. Introduce one realistic failure or invalid input. 4. Observe the result, fix the issue, and document the trade-off. ## Architecture ```mermaid flowchart LR User[User or operator] --> App[DevOps Engineer Foundations] App --> Control[Git] Control --> Signal[Logs, metrics, tests] Signal --> Decision[Verify, recover, improve] ``` ## Checkpoint Explain the concept in your own words, show the lab result, and name one production risk before marking this tutorial complete.

GOAL: Git delivery workflows
TOOLS: Git, GitHub

CHECKLIST
[ ] Define the inputs and success signal
[ ] Build the smallest working example
[ ] Validate failures and unsafe input
[ ] Add a log, metric, or test
[ ] Document rollback or recovery
[ ] Explain one trade-off
05

Build and package applications

90 min · beginner

Make builds repeatable with lockfiles, artifacts, and environment separation.

Open notes and cheat sheet

# Build and package applications ## Outcome By the end of this chapter you can explain and apply the core ideas in a small, testable lab. ## Explanation Make builds repeatable with lockfiles, artifacts, and environment separation. Connect the concept to the user, operator, and failure-mode impact. Start with the smallest working example, then add validation, observability, and recovery. ## Tools npm, Make ## Guided lab 1. Write down the input, expected behavior, and measurable success condition. 2. Build the smallest example and run it locally. 3. Introduce one realistic failure or invalid input. 4. Observe the result, fix the issue, and document the trade-off. ## Architecture ```mermaid flowchart LR User[User or operator] --> App[DevOps Engineer Foundations] App --> Control[npm] Control --> Signal[Logs, metrics, tests] Signal --> Decision[Verify, recover, improve] ``` ## Checkpoint Explain the concept in your own words, show the lab result, and name one production risk before marking this tutorial complete.

GOAL: Build and package applications
TOOLS: npm, Make

CHECKLIST
[ ] Define the inputs and success signal
[ ] Build the smallest working example
[ ] Validate failures and unsafe input
[ ] Add a log, metric, or test
[ ] Document rollback or recovery
[ ] Explain one trade-off
06

Containers from first principles

90 min · beginner

Understand images, layers, registries, namespaces, and container lifecycle.

Open notes and cheat sheet

# Containers from first principles ## Outcome By the end of this chapter you can explain and apply the core ideas in a small, testable lab. ## Explanation Understand images, layers, registries, namespaces, and container lifecycle. Connect the concept to the user, operator, and failure-mode impact. Start with the smallest working example, then add validation, observability, and recovery. ## Tools Docker ## Guided lab 1. Write down the input, expected behavior, and measurable success condition. 2. Build the smallest example and run it locally. 3. Introduce one realistic failure or invalid input. 4. Observe the result, fix the issue, and document the trade-off. ## Architecture ```mermaid flowchart LR User[User or operator] --> App[DevOps Engineer Foundations] App --> Control[Docker] Control --> Signal[Logs, metrics, tests] Signal --> Decision[Verify, recover, improve] ``` ## Checkpoint Explain the concept in your own words, show the lab result, and name one production risk before marking this tutorial complete.

GOAL: Containers from first principles
TOOLS: Docker

CHECKLIST
[ ] Define the inputs and success signal
[ ] Build the smallest working example
[ ] Validate failures and unsafe input
[ ] Add a log, metric, or test
[ ] Document rollback or recovery
[ ] Explain one trade-off
GOAL: Compose local systems
TOOLS: Docker Compose

CHECKLIST
[ ] Define the inputs and success signal
[ ] Build the smallest working example
[ ] Validate failures and unsafe input
[ ] Add a log, metric, or test
[ ] Document rollback or recovery
[ ] Explain one trade-off
03

CI pipeline design

90 min · intermediate

Create fast feedback with formatting, lint, types, tests, artifacts, and caching.

Open notes and cheat sheet

# CI pipeline design ## Outcome By the end of this chapter you can explain and apply the core ideas in a small, testable lab. ## Explanation Create fast feedback with formatting, lint, types, tests, artifacts, and caching. Connect the concept to the user, operator, and failure-mode impact. Start with the smallest working example, then add validation, observability, and recovery. ## Tools GitHub Actions ## Guided lab 1. Write down the input, expected behavior, and measurable success condition. 2. Build the smallest example and run it locally. 3. Introduce one realistic failure or invalid input. 4. Observe the result, fix the issue, and document the trade-off. ## Architecture ```mermaid flowchart LR User[User or operator] --> App[DevOps Engineer Foundations] App --> Control[GitHub Actions] Control --> Signal[Logs, metrics, tests] Signal --> Decision[Verify, recover, improve] ``` ## Checkpoint Explain the concept in your own words, show the lab result, and name one production risk before marking this tutorial complete.

GOAL: CI pipeline design
TOOLS: GitHub Actions

CHECKLIST
[ ] Define the inputs and success signal
[ ] Build the smallest working example
[ ] Validate failures and unsafe input
[ ] Add a log, metric, or test
[ ] Document rollback or recovery
[ ] Explain one trade-off
04

Continuous delivery

90 min · intermediate

Promote immutable artifacts through environments with approvals and rollback.

Open notes and cheat sheet

# Continuous delivery ## Outcome By the end of this chapter you can explain and apply the core ideas in a small, testable lab. ## Explanation Promote immutable artifacts through environments with approvals and rollback. Connect the concept to the user, operator, and failure-mode impact. Start with the smallest working example, then add validation, observability, and recovery. ## Tools GitHub Actions ## Guided lab 1. Write down the input, expected behavior, and measurable success condition. 2. Build the smallest example and run it locally. 3. Introduce one realistic failure or invalid input. 4. Observe the result, fix the issue, and document the trade-off. ## Architecture ```mermaid flowchart LR User[User or operator] --> App[DevOps Engineer Foundations] App --> Control[GitHub Actions] Control --> Signal[Logs, metrics, tests] Signal --> Decision[Verify, recover, improve] ``` ## Checkpoint Explain the concept in your own words, show the lab result, and name one production risk before marking this tutorial complete.

GOAL: Continuous delivery
TOOLS: GitHub Actions

CHECKLIST
[ ] Define the inputs and success signal
[ ] Build the smallest working example
[ ] Validate failures and unsafe input
[ ] Add a log, metric, or test
[ ] Document rollback or recovery
[ ] Explain one trade-off
05

Infrastructure as code

90 min · intermediate

Model infrastructure as reviewable, repeatable, idempotent code.

Open notes and cheat sheet

# Infrastructure as code ## Outcome By the end of this chapter you can explain and apply the core ideas in a small, testable lab. ## Explanation Model infrastructure as reviewable, repeatable, idempotent code. Connect the concept to the user, operator, and failure-mode impact. Start with the smallest working example, then add validation, observability, and recovery. ## Tools Terraform ## Guided lab 1. Write down the input, expected behavior, and measurable success condition. 2. Build the smallest example and run it locally. 3. Introduce one realistic failure or invalid input. 4. Observe the result, fix the issue, and document the trade-off. ## Architecture ```mermaid flowchart LR User[User or operator] --> App[DevOps Engineer Foundations] App --> Control[Terraform] Control --> Signal[Logs, metrics, tests] Signal --> Decision[Verify, recover, improve] ``` ## Checkpoint Explain the concept in your own words, show the lab result, and name one production risk before marking this tutorial complete.

GOAL: Infrastructure as code
TOOLS: Terraform

CHECKLIST
[ ] Define the inputs and success signal
[ ] Build the smallest working example
[ ] Validate failures and unsafe input
[ ] Add a log, metric, or test
[ ] Document rollback or recovery
[ ] Explain one trade-off
06

Terraform state and modules

90 min · intermediate

Manage state safely, compose modules, and separate development from production.

Open notes and cheat sheet

# Terraform state and modules ## Outcome By the end of this chapter you can explain and apply the core ideas in a small, testable lab. ## Explanation Manage state safely, compose modules, and separate development from production. Connect the concept to the user, operator, and failure-mode impact. Start with the smallest working example, then add validation, observability, and recovery. ## Tools Terraform, S3 ## Guided lab 1. Write down the input, expected behavior, and measurable success condition. 2. Build the smallest example and run it locally. 3. Introduce one realistic failure or invalid input. 4. Observe the result, fix the issue, and document the trade-off. ## Architecture ```mermaid flowchart LR User[User or operator] --> App[DevOps Engineer Foundations] App --> Control[Terraform] Control --> Signal[Logs, metrics, tests] Signal --> Decision[Verify, recover, improve] ``` ## Checkpoint Explain the concept in your own words, show the lab result, and name one production risk before marking this tutorial complete.

GOAL: Terraform state and modules
TOOLS: Terraform, S3

CHECKLIST
[ ] Define the inputs and success signal
[ ] Build the smallest working example
[ ] Validate failures and unsafe input
[ ] Add a log, metric, or test
[ ] Document rollback or recovery
[ ] Explain one trade-off
GOAL: Secrets and configuration
TOOLS: AWS Secrets Manager, env

CHECKLIST
[ ] Define the inputs and success signal
[ ] Build the smallest working example
[ ] Validate failures and unsafe input
[ ] Add a log, metric, or test
[ ] Document rollback or recovery
[ ] Explain one trade-off
03

Monitoring and alerting

90 min · intermediate

Choose actionable metrics, logs, dashboards, alerts, and ownership.

Open notes and cheat sheet

# Monitoring and alerting ## Outcome By the end of this chapter you can explain and apply the core ideas in a small, testable lab. ## Explanation Choose actionable metrics, logs, dashboards, alerts, and ownership. Connect the concept to the user, operator, and failure-mode impact. Start with the smallest working example, then add validation, observability, and recovery. ## Tools CloudWatch, Prometheus ## Guided lab 1. Write down the input, expected behavior, and measurable success condition. 2. Build the smallest example and run it locally. 3. Introduce one realistic failure or invalid input. 4. Observe the result, fix the issue, and document the trade-off. ## Architecture ```mermaid flowchart LR User[User or operator] --> App[DevOps Engineer Foundations] App --> Control[CloudWatch] Control --> Signal[Logs, metrics, tests] Signal --> Decision[Verify, recover, improve] ``` ## Checkpoint Explain the concept in your own words, show the lab result, and name one production risk before marking this tutorial complete.

GOAL: Monitoring and alerting
TOOLS: CloudWatch, Prometheus

CHECKLIST
[ ] Define the inputs and success signal
[ ] Build the smallest working example
[ ] Validate failures and unsafe input
[ ] Add a log, metric, or test
[ ] Document rollback or recovery
[ ] Explain one trade-off
04

Release strategies

90 min · advanced

Use blue-green, canary, feature flags, migrations, and rollback plans.

Open notes and cheat sheet

# Release strategies ## Outcome By the end of this chapter you can explain and apply the core ideas in a small, testable lab. ## Explanation Use blue-green, canary, feature flags, migrations, and rollback plans. Connect the concept to the user, operator, and failure-mode impact. Start with the smallest working example, then add validation, observability, and recovery. ## Tools ALB, feature flags ## Guided lab 1. Write down the input, expected behavior, and measurable success condition. 2. Build the smallest example and run it locally. 3. Introduce one realistic failure or invalid input. 4. Observe the result, fix the issue, and document the trade-off. ## Architecture ```mermaid flowchart LR User[User or operator] --> App[DevOps Engineer Foundations] App --> Control[ALB] Control --> Signal[Logs, metrics, tests] Signal --> Decision[Verify, recover, improve] ``` ## Checkpoint Explain the concept in your own words, show the lab result, and name one production risk before marking this tutorial complete.

GOAL: Release strategies
TOOLS: ALB, feature flags

CHECKLIST
[ ] Define the inputs and success signal
[ ] Build the smallest working example
[ ] Validate failures and unsafe input
[ ] Add a log, metric, or test
[ ] Document rollback or recovery
[ ] Explain one trade-off
05

Kubernetes essentials

90 min · advanced

Understand pods, deployments, services, config, probes, and scheduling.

Open notes and cheat sheet

# Kubernetes essentials ## Outcome By the end of this chapter you can explain and apply the core ideas in a small, testable lab. ## Explanation Understand pods, deployments, services, config, probes, and scheduling. Connect the concept to the user, operator, and failure-mode impact. Start with the smallest working example, then add validation, observability, and recovery. ## Tools Kubernetes, kubectl ## Guided lab 1. Write down the input, expected behavior, and measurable success condition. 2. Build the smallest example and run it locally. 3. Introduce one realistic failure or invalid input. 4. Observe the result, fix the issue, and document the trade-off. ## Architecture ```mermaid flowchart LR User[User or operator] --> App[DevOps Engineer Foundations] App --> Control[Kubernetes] Control --> Signal[Logs, metrics, tests] Signal --> Decision[Verify, recover, improve] ``` ## Checkpoint Explain the concept in your own words, show the lab result, and name one production risk before marking this tutorial complete.

GOAL: Kubernetes essentials
TOOLS: Kubernetes, kubectl

CHECKLIST
[ ] Define the inputs and success signal
[ ] Build the smallest working example
[ ] Validate failures and unsafe input
[ ] Add a log, metric, or test
[ ] Document rollback or recovery
[ ] Explain one trade-off
06

GitOps operations

90 min · advanced

Reconcile desired state from Git and make changes auditable.

Open notes and cheat sheet

# GitOps operations ## Outcome By the end of this chapter you can explain and apply the core ideas in a small, testable lab. ## Explanation Reconcile desired state from Git and make changes auditable. Connect the concept to the user, operator, and failure-mode impact. Start with the smallest working example, then add validation, observability, and recovery. ## Tools Argo CD, Helm ## Guided lab 1. Write down the input, expected behavior, and measurable success condition. 2. Build the smallest example and run it locally. 3. Introduce one realistic failure or invalid input. 4. Observe the result, fix the issue, and document the trade-off. ## Architecture ```mermaid flowchart LR User[User or operator] --> App[DevOps Engineer Foundations] App --> Control[Argo CD] Control --> Signal[Logs, metrics, tests] Signal --> Decision[Verify, recover, improve] ``` ## Checkpoint Explain the concept in your own words, show the lab result, and name one production risk before marking this tutorial complete.

GOAL: GitOps operations
TOOLS: Argo CD, Helm

CHECKLIST
[ ] Define the inputs and success signal
[ ] Build the smallest working example
[ ] Validate failures and unsafe input
[ ] Add a log, metric, or test
[ ] Document rollback or recovery
[ ] Explain one trade-off
GOAL: Supply-chain security
TOOLS: SLSA, SBOM, Cosign

CHECKLIST
[ ] Define the inputs and success signal
[ ] Build the smallest working example
[ ] Validate failures and unsafe input
[ ] Add a log, metric, or test
[ ] Document rollback or recovery
[ ] Explain one trade-off
03

Platform handoff

90 min · advanced

Define service ownership, golden paths, documentation, and operational readiness.

Open notes and cheat sheet

# Platform handoff ## Outcome By the end of this chapter you can explain and apply the core ideas in a small, testable lab. ## Explanation Define service ownership, golden paths, documentation, and operational readiness. Connect the concept to the user, operator, and failure-mode impact. Start with the smallest working example, then add validation, observability, and recovery. ## Tools Backstage, templates ## Guided lab 1. Write down the input, expected behavior, and measurable success condition. 2. Build the smallest example and run it locally. 3. Introduce one realistic failure or invalid input. 4. Observe the result, fix the issue, and document the trade-off. ## Architecture ```mermaid flowchart LR User[User or operator] --> App[DevOps Engineer Foundations] App --> Control[Backstage] Control --> Signal[Logs, metrics, tests] Signal --> Decision[Verify, recover, improve] ``` ## Checkpoint Explain the concept in your own words, show the lab result, and name one production risk before marking this tutorial complete.

GOAL: Platform handoff
TOOLS: Backstage, templates

CHECKLIST
[ ] Define the inputs and success signal
[ ] Build the smallest working example
[ ] Validate failures and unsafe input
[ ] Add a log, metric, or test
[ ] Document rollback or recovery
[ ] Explain one trade-off
04

DevOps capstone

90 min · advanced

Ship a tested container through CI/CD to an observable production target.

Open notes and cheat sheet

# DevOps capstone ## Outcome By the end of this chapter you can explain and apply the core ideas in a small, testable lab. ## Explanation Ship a tested container through CI/CD to an observable production target. Connect the concept to the user, operator, and failure-mode impact. Start with the smallest working example, then add validation, observability, and recovery. ## Tools Docker, Terraform, AWS ## Guided lab 1. Write down the input, expected behavior, and measurable success condition. 2. Build the smallest example and run it locally. 3. Introduce one realistic failure or invalid input. 4. Observe the result, fix the issue, and document the trade-off. ## Architecture ```mermaid flowchart LR User[User or operator] --> App[DevOps Engineer Foundations] App --> Control[Docker] Control --> Signal[Logs, metrics, tests] Signal --> Decision[Verify, recover, improve] ``` ## Checkpoint Explain the concept in your own words, show the lab result, and name one production risk before marking this tutorial complete.

GOAL: DevOps capstone
TOOLS: Docker, Terraform, AWS

CHECKLIST
[ ] Define the inputs and success signal
[ ] Build the smallest working example
[ ] Validate failures and unsafe input
[ ] Add a log, metric, or test
[ ] Document rollback or recovery
[ ] Explain one trade-off