I built an engineering roadmap that skips the video tutorials

Abhirup Karmakar — Thu, 10 Sep 2026 09:02:47 +0000

Most developer roadmaps sell a fantasy that looks like this:

HTML → CSS → JavaScript → React → Next.js → "Senior Engineer"

You follow a 40-hour video playlist, copy whatever the instructor types into VS Code, and feel like you're learning. But the moment you close the tab and try to deploy a service on a bare Linux VM, diagnose why a socket connection is hanging, or figure out why your Docker container runs out of memory, you hit a wall.

I got frustrated with two things in the current learning ecosystem:

Video tutorial hell: Watching someone code is passive. It gives you the illusion of competence without forcing your brain to synthesize anything.
Disconnected toy projects: Building 15 separate "ToDo list" apps doesn't teach you how production systems actually work. Real engineering is about state, networking, failure modes, cost, and observability.

So over the past few months, I put together an opinionated, text-first engineering roadmap designed to build real systems instincts.

Live Interactive Site: wyrcan-io.github.io/roadmap

GitHub Repo: github.com/Wyrcan-io/roadmap

The 4 Non-Negotiable Rules

I built the curriculum around 4 strict principles:

70% Building, 30% Reading: You don't read books front-to-back like a novel. You read official docs and canonical chapters to unblock real implementations.
One Evolving Platform: Instead of hoarding 20 toy repositories, you spend all 12 stages incrementally building, containerizing, provisioning, and scaling a single production-grade AI platform.
Deliberate Failure Testing: Deploying happy paths teaches you very little. The curriculum mandates injecting failures—inducing network latency, triggering OOM crashes, simulating data drift—and writing blameless postmortems.
Canonical Books & Official Docs Only: Zero YouTube playlists. If you want to understand operating systems, read OSTEP. For machine learning, read ISLP. For deep learning, read UDL. For distributed systems, read Martin Kleppmann's Designing Data-Intensive Applications (DDIA).

The 12-Stage Progression

The roadmap bridges the gap between low-level systems, cloud infrastructure, and modern ML/DevOps:

Stage 00 — Foundation Reset: Python internals, async event loops, OSTEP process model, raw HTTP, and PostgreSQL query plans.
Stage 01 — Linux & Networking: systemd, POSIX permissions, sockets, TCP/IP, and deploying FastAPI behind Nginx.
Stage 02 — Docker Deep Dive: OCI spec, Linux namespaces/cgroups, multi-stage builds, and bridge network isolation.
Stage 03 — AWS Cloud Engineering: VPC topology, private subnets, IAM least privilege, RDS, and ALB.
Stage 04 — CI/CD & Security: Automated GitHub Actions workflows, Trivy container scanning, and zero-downtime rollbacks.
Stage 05 — Infrastructure as Code: Terraform modular architecture, remote state locking with S3 & DynamoDB.
Stage 06 — ML Fundamentals: Statistical learning via ISLP and building clean tabular training pipelines.
Stage 07 — Deep Learning with PyTorch: Autograd from scratch, tensor operations, and custom training loops (UDL).
Stage 08 — ML Engineering & Lineage: Google's Rules of ML, experiment tracking, and model registries with MLflow.
Stage 09 — Continuous Training (CT): Automated evaluation gates and canary routing.
Stage 10 — Kubernetes (EKS / K3s): Pod lifecycles, Ingress controllers, Helm 3 charts, and cluster debugging.
Stage 11 — Observability & SRE: OpenTelemetry distributed tracing, Prometheus metrics, Grafana dashboards, and SLO alerting.
Stage 12 — Capstone Hardening: C4 architecture diagrams, cost optimization, and an AWS Well-Architected review.
Continuous Loop: 1 chapter of DDIA 2nd Edition alongside every stage.

Dual-Track Pacing (Because Nobody Finishes a 6-Month "Fast Track")

Pretending someone can master Linux, AWS, Terraform, PyTorch, Kubernetes, and distributed systems in 3 months is dishonest. We built an interactive switcher on the site with two realistic paces:

Working Practitioner Track (Recommended): 24 months (~8 weeks per stage) at 8–10 hours/week. Designed for working professionals and university students who have a life.
Accelerated Sprint Track: 12 months (~4 weeks per stage) at 20–25 hours/week for engineers on dedicated career breaks or sabbaticals.

What's on the Site

The site is built with vanilla HTML, CSS, and JS (fast, lightweight, warm ivory/espresso theme):

106 interactive checkpoints saved locally in your browser's localStorage.
Export to Markdown button to paste your progress directly into Notion or Obsidian.
Search filter across all 59 primary sources and documentation links.
Google Docs-style outline with live scroll tracking.

It's 100% free, has no email paywalls, and no tracking.

Check it out here: wyrcan-io.github.io/roadmap

If you have feedback on the sequencing or want to suggest better primary texts, open an issue or PR on GitHub.

I got tired of tutorial hell, so I built a systems-first engineering roadmap

Abhirup Karmakar — Thu, 10 Sep 2026 09:00:27 +0000

I got tired of roadmaps that jump straight from basic JavaScript into React and treat that as "software engineering".

Whenever you run into actual production issues—memory leaks, slow queries, networking bottlenecks, or weird Docker crashes—framework tutorials don't help. You need to understand how the operating system and network actually work.

I spent the last few months putting together a text-only curriculum around that:
https://wyrcan-io.github.io/roadmap/

A few choices I made with it:

No video tutorials. It only links to official documentation and canonical textbooks (OSTEP for operating systems, DDIA for distributed systems, ISLP for ML). Text is much faster to reference and forces you to actually write code instead of passively watching someone else type.
Instead of building a dozen random "Hello World" apps, the idea is to build and evolve one system through 12 stages: deploying a service on bare Linux, containerizing it, writing Terraform, setting up CI/CD, adding telemetry, etc.
There are 106 checkpoints you can check off as you work through it. Progress saves in your browser's localStorage, and there's a button to export your progress as markdown into Obsidian or Notion.

The repo is here if you want to fork it or look at the sources:
https://github.com/Wyrcan-io/roadmap