Hands-on course · one app · end to end
How to Become a DevOps Engineer
Take one small web application — the Pretzel Shop monolith — from a laptop install all the way to a production-shaped AWS deployment. Learn the core DevOps job along the way: running services, containers, CI, observability, incident drills, cloud networking, managed services, Terraform, and AI-assisted workflows.
Who this is for
Built for people who learn by shipping — not by watching.
You're breaking into DevOps from dev, sysadmin, or IT. You want one coherent thread through the real job — not a pile of disconnected tutorials. You're willing to put in ~80–100 hours of hands-on work on a single application.
Prerequisites
- →Basic programming comfort in any language — read JavaScript, run commands from a terminal.
- →Unix-style shell (macOS, Linux, or WSL) and familiarity with cd, ls, editing files from the CLI.
- →Git installed and a GitHub account — no prior Git workflow assumed.
- →Ability to install software and create cloud accounts; AWS resources cost real money while running.
- →No prior Docker, Terraform, or AWS experience required. The course starts with none of them.
What you'll build
One monolith. Every layer of the DevOps job.
The Pretzel Shop — Node.js / Express API, React frontend, PostgreSQL, Redis — stays the same app from Section 1 to Section 21. You evolve how it runs, not what it is.
-
Pretzel Shop monolith
Node.js / Express API, React (Vite) frontend, PostgreSQL, Redis — one app, start to finish.
-
VM + systemd
Ubuntu 24.04 on VirtualBox, services managed by systemd, survives reboots without retyping commands.
-
Docker + Compose
Multi-stage images, non-root containers, SIGTERM draining, one docker compose up for the full stack.
-
GHCR + Cosign
GitHub Actions builds, Trivy scans, pushes to GHCR, keyless-signs images via OIDC — no long-lived signing keys.
-
LGTM observability stack
OpenTelemetry, Prometheus, Loki, Tempo, Pyroscope, Grafana — locally and in the cloud, with incident drills and runbooks.
-
ECS Fargate on AWS
VPC, ALB, ACM, Route 53, RDS PostgreSQL, ElastiCache Redis — production-shaped multi-AZ layout.
-
Terraform
Multi-environment IaC with remote state, pre-commit guardrails, plan-before-apply in CI — the full Pretzel Shop baseline as code.
Roadmap
21 sections in 8 parts — one thread, no detours.
Local Foundations
Git and app anatomy → Ubuntu VM with systemd → Nginx + HTTPS + bootstrap script → Docker Compose → production-ready containers (multi-stage, non-root, SIGTERM draining, 12-factor).
CI/CD & AI
GitHub Actions: lint, test, build, Trivy scan, GHCR push, Cosign keyless sign → CI developer experience (summaries, annotations, caching) → Cursor rules and AI-assisted integration + k6 tests.
Observability
Local LGTM + Pyroscope stack with OpenTelemetry → Grafana dashboards and golden signals → outage drills, runbooks, and blameless RCAs for Redis and Postgres failures.
Cloud Deploy
First cloud deployment on a single VM (provider-agnostic) → GHCR image deploy via GitHub Actions — no git pull on production, pull images by commit SHA.
Architecture
VM vs. managed services trade-offs and ADRs → AWS VPC networking (multi-AZ, NAT, security groups, endpoints) → ECS Fargate reference architecture with ALB, RDS, ElastiCache.
IaC
Terraform for the full Pretzel Shop on ECS Fargate — multi-env layout, remote state, composable modules → pre-commit, TFLint, Checkov, plan artifacts, manual apply only.
Cloud Ops
Shared VPC observability stack in Terraform with separate state → RDS reboot outage drill in staging with real runbook and RCA committed to the repo.
Capstone
End-to-end system map: request path, failure domains, change flow from git push to running tasks, and three explicit gaps for your next projects — interview-ready artifact.
Tech stack
Tools you'll actually touch.
Runtime
Node.js 24 · Express
Frontend
React · Vite · Nginx
Data
PostgreSQL · Redis
Containers
Docker · Compose v2
CI/CD
GitHub Actions · GHCR
Security
Trivy · Cosign · Certbot
Observability
OTel · LGTM · Pyroscope
Cloud
ECS Fargate · RDS · ALB
IaC
Terraform · Checkov · TFLint
Load testing
k6
AI tooling
Cursor · repo rules
Host OS
Ubuntu 24.04 LTS
Learning outcomes
What you'll be able to do when you're done.
- ✓Install, run, and debug a full-stack monolith locally — and explain what each layer does when something breaks.
- ✓Provision a VM, manage services with systemd, put Nginx in front with TLS, and reproduce the setup from a bootstrap script.
- ✓Containerize with multi-stage Dockerfiles, run as non-root, handle SIGTERM gracefully, and ship images through a real CI pipeline.
- ✓Build GitHub Actions workflows that lint, test, scan with Trivy, push to GHCR, and keyless-sign with Cosign.
- ✓Run an LGTM + Pyroscope observability stack, build Grafana dashboards around golden signals, and investigate incidents with runbooks and RCAs.
- ✓Deploy to a cloud VM and to AWS ECS Fargate with managed Postgres and Redis — and explain the networking paths.
- ✓Provision and manage AWS infrastructure with Terraform — multi-env layout, remote state, plan-before-apply guardrails.
- ✓Produce a system map that names failure domains, change flow, and explicit gaps — the kind of artifact that holds up in an interview.
Ready to build the DevOps skills for real?
~20 minutes on a call. Tell me where you are and what you're aiming for — I'll walk you through how this course fits and whether it's the right move for you.
Book a call →Why this course
Starts at zero Docker and zero AWS.
Most DevOps courses assume you already know containers and a cloud console. This one doesn't. You start by installing the Pretzel Shop on your laptop — no Docker, no AWS — and follow one Node.js / Express monolith through every layer of the job until it's running on ECS Fargate with Terraform, observability, and incident runbooks in Git. One app. One thread. The way you'd actually learn on the job.