Why is this roadmap text-first rather than based on video tutorials?

Text-first resources—official vendor documentation, university lecture notes, canonical RFCs, and peer-reviewed textbooks (ISLP, UDL, DDIA, OSTEP)—offer 5 to 10 times the information density of video playlists. They allow rapid non-linear lookup, reflect how senior engineers debug and build on the job, and prevent passive 'tutorial hell' by forcing hands-on code synthesis.

What are the core technical deliverables built across the curriculum?

Deliverables include a hardened Linux service behind Nginx, multi-stage Docker container stacks, multi-tier AWS cloud infrastructure provisioned via modular Terraform, automated GitHub Actions CI/CD pipelines with vulnerability scanning, custom PyTorch neural networks, reproducible MLflow model registries, automated continuous training pipelines, an EKS Kubernetes deployment with Helm, and full OpenTelemetry telemetry dashboards with incident postmortems.

Curriculum & Resource Stack

Engineering Roadmap: Fundamentals to Production

Q: What should I learn before distributed systems and system design?

Before studying distributed systems, build a solid mental model of Operating Systems (processes, threads, memory hierarchy, sockets via OSTEP), Computer Networking (TCP/IP handshake, DNS, packet routing via Beej's Guide), and relational database storage engines (indexes, transactions, query execution plans in PostgreSQL). Trying to design distributed systems without understanding single-node bottlenecks leads to shallow buzzword memorization.

Q: How is this roadmap different from roadmap.sh or developer bootcamps?

Most bootcamps and roadmaps focus narrowly on UI frameworks (HTML -> React -> Next.js) or generate disconnected 'Hello World' repos. The Wyrcan Roadmap is systems-first and platform-centric: you evolve a single production-grade AI platform across 12 cumulative milestones, deliberately induce failures, monitor telemetry with OpenTelemetry and Prometheus, and harden real cloud infrastructure with Terraform and Kubernetes.

Q: Can I follow this engineering roadmap while working a full-time job?

Yes. The curriculum features a dedicated Working Practitioner Track designed specifically for 8–10 hours per week over 24 months (~8 weeks per milestone). This allocates 4 weeks to reading canonical texts and completing exercises, and 4 weeks to shipping production deliverables and runbooks without burning out.

A text-first, 12-stage practitioner curriculum (12–24 months) spanning AI/ML, Cloud, DevOps, MLOps, and Systems. Grounded entirely in official vendor documentation, university courses, foundational books, and working code. Zero tutorial fluff.

70% Build

Use books and official docs to unblock real implementations. Building is the actual curriculum.

One System

Evolve a single production-grade AI platform across your 12 milestones rather than hoarding disconnected toy repos.

Break Things

Deploy, induce real failures, trace errors through telemetry, fix them, and write postmortems.

Design First

Reason methodically about traffic, consistency, latency, cost, and failure modes before writing code.

The Practitioner Standard

This roadmap prioritizes official documentation, university course notes, open textbooks, and practitioner-recommended books that working engineers keep using on the job. Video tutorials are deliberately excluded: text and hands-on labs provide vastly higher density and retention.

Core Work through thoroughly Hands-On Complete the exercises Book Essential reading Paper Fundamental research Reference Consult when needed Free Openly accessible

Interactive Engineering Pacing

Choose Your Track (12 vs 24 Months)

Mastering canonical textbooks (ISLP, UDL, DDIA), 7 platform ecosystems, and 110 checkpoints takes deliberate compounding. Click either card below to adapt the entire curriculum timeline to your schedule.

Recommended Pace 8–10 hrs / week

Working Practitioner Track

24 Months (~8 weeks / stage)

Built for working engineers, full-time professionals, and university students. Eliminates burnout while ensuring concepts convert into permanent engineering instincts.

Weeks 1–4: Deep textbook reading, official documentation & lab exercises.
Weeks 5–8: Production deliverable implementation, failure testing & runbook.
System Design: 1 DDIA chapter every 6–8 weeks (deep retention).

Active Track Selected (Default)

Full-Time / Sabbatical 20–25+ hrs / week

Accelerated Sprint Track

12 Months (~4 weeks / stage)

For engineers on dedicated career sabbaticals or full-time self-learners who can treat this curriculum as their primary daily job (4–5 hours every day).

Weeks 1–2: Rapid reading & lab problem sets.
Weeks 3–4: Architecture provisioning, pipeline build & exit test.
System Design: 1 DDIA chapter every 3–4 weeks (high cognitive load).

Select Track Click to activate

Sequence TLCL + Daily Linux → Bandit Wargame → Beej Network Concepts → Deploy FastAPI / Nginx VM

Learn

Filesystem, users, permissions, processes, signals systemd, services, journalctl, logs SSH, SCP, keys, basic hardening DNS, TCP/UDP, ports, TLS, firewalls, reverse proxies Deploy FastAPI service on Linux VM behind Nginx with HTTPS

Production Deliverable

Deploy a FastAPI service manually to a Linux VM behind Nginx + HTTPS. Create an operational runbook for "API is down / degraded".

Exit Test: Diagnose process, DNS, port, and service crashes using standard CLI tools without reinstalling the machine.

Sequence Helsinki MOOC → Official Best Practices → Compose Multi-tier Stack → Break Networks & Volumes

Learn

Images, layers, build context, caching Dockerfiles + multi-stage builds Volumes, networks, Compose Health checks, resource limits, registries, security Multi-tier Docker Compose setup (Next.js + FastAPI + Postgres + Redis)

Production Deliverable

Containerize Next.js + FastAPI + PostgreSQL + Redis using a hardened, production-oriented Docker Compose setup.

Exit Test: Intentionally corrupt networking, persistence, and environment variables, then restore clean operational state.

Sequence Skill Builder Fundamentals → Manually Provision Architecture → Well-Architected Review → Builders' Library

Learn

IAM + least privilege VPC, public/private subnets, routing, security groups EC2, S3, RDS, ECR ALB, Route 53, CloudWatch, Secrets Manager Manually deploy full architecture on AWS with design doc

Production Deliverable

Manually provision and deploy the Stage 2 multi-tier stack on AWS. Write a detailed system design document justifying every public/private boundary, traffic path, and failure domain.

Exit Test: Explain exactly where data, credentials, application logs, and network traffic traverse at every hop.

Sequence GitHub Actions Pipeline → Twelve-Factor Principles → OWASP CI/CD Hardening → Google SRE Chapters

Learn

GitHub Actions, CI stages, caching, artifacts Tests, linting, type checks, security scans Deployments, environments, secrets, approvals Rollback and failure handling Full push-to-deploy pipeline with automated rollback

Production Deliverable

Push → Lint → Test → Container Build → Trivy Scan → ECR Push → Deploy → Health Check verification pipeline with automated rollback on failure.

Exit Test: A failing test, security vulnerability, or broken database migration must halt the pipeline safely before hitting production.

Sequence AWS Get Started → Remote State & Locking → Reusable Modules → Drift & Import

Learn

Providers, resources, variables, outputs State, remote state, locking, drift Modules, data sources, environments plan / apply / import / destroy workflows Spin up & destroy entire AWS architecture from modular Terraform

Production Deliverable

Recreate your entire AWS cloud architecture as clean modular Terraform code. Destroy and spin up a staging environment from scratch in minutes.

Exit Test: Demonstrate handling state locks, importing existing resources, and detecting/remediating manual console drift.

Sequence Google MLCC Overview → ISLP + Python Labs → scikit-learn MOOC → Build Classical ML Service

Learn

Probability/statistics essentials + linear algebra refresh NumPy, Pandas, scikit-learn Regression, trees, ensembles, clustering Splits, CV, leakage, overfitting, precision/recall/F1/AUC End-to-end scikit-learn tabular pipeline + FastAPI endpoint

Production Deliverable

Build an end-to-end classical ML service from raw tabular dataset to validated model pipeline and FastAPI inference endpoint.

Exit Test: Explain why a model overfits, identify data leakage in feature preprocessing, and justify metric choice.

Sequence PyTorch Basics → Custom Training Loop → Understanding Deep Learning → Transformers & GPU Profiling

Learn

Tensors, datasets, dataloaders Training loops, losses, optimizers, backprop GPU basics, profiling, checkpointing CNNs, embeddings, transformers, transfer learning Trained PyTorch model + versioned weights + GPU inference endpoint

Production Deliverable

Train a deep learning model from scratch or fine-tune with transfer learning. Save versioned weights and expose inference via an optimized API.

Exit Test: Profile and diagnose GPU memory leaks, OOM crashes, and batch throughput bottlenecks during inference.

Sequence Rules of ML → Hidden Technical Debt Paper → MLflow Tracking & Registry → Reproducible Pipeline

Learn

Reproducibility, configs, seeds, data validation Batch vs online inference, serialization, versioning Testing ML code and prediction contracts MLflow tracking + model registry Traceable training pipeline (git commit + dataset hash + MLflow registry)

Production Deliverable

Build a repeatable ML training pipeline where every model version is completely traceable to git commit, dataset hash, hyperparameters, and evaluation metrics.

Exit Test: Reproduce any previously registered model and its metrics from code and artifacts alone without guesswork.

Sequence Google MLOps Architecture → MLOps Principles → MLOps Zoomcamp → Automate Model Promotion

Learn

Data → train → evaluate → validate → register Quality gates and model promotion rules Automated model build/deploy workflows Lineage, metadata and rollback Automated model promotion pipeline with canary routing

Production Deliverable

A model that satisfies validation thresholds enters the model registry and automatically triggers a safe staging deployment with canary routing.

Exit Test: Deploy and promote a new model revision without manually copying artifacts or altering hardcoded paths.

Sequence Kubernetes Basics → Helsinki K8s MOOC → Helm Packaging → Amazon EKS Workshop

Learn

Pods, deployments, services, namespaces ConfigMaps, secrets, volumes, ingress Requests/limits, probes, autoscaling Helm; local cluster first, then EKS Package in Helm and deploy to AWS EKS with autoscaling

Production Deliverable

Package your application stack into Helm charts and deploy across local K3s and AWS EKS with autoscaling and ingress.

Exit Test: Debug and resolve "Pod running but Service unreachable", crash loops, and failed persistent volume claims.

Sequence OpenTelemetry Primer → Prometheus Instrumentation → Grafana Dashboards → SRE SLO Chapters → Evidently / NannyML

Learn

Logs, metrics, traces (The Three Pillars) SLIs, SLOs, alerts, error budgets Latency, throughput, CPU/GPU/memory, cost Data drift, model drift, prediction monitoring Production Grafana dashboards + induced failure incident postmortem

Production Deliverable

Production Prometheus/Grafana dashboards + actionable alert rules + induce a deliberate failure incident and produce a blameless postmortem.

Exit Test: Diagnose what broke, why it broke, and the time-to-recovery using telemetry data rather than intuition.

The Non-Negotiable 13-Pillar Backbone

Executive Summary

If the entire catalog feels vast, these 13 items form your core intellectual spine:

Foundation: MIT Missing Semester + OSTEP + Pro Git + MDN HTTP

Linux & Networking: The Linux Command Line + Beej Network Concepts

Docker: Helsinki DevOps with Docker + official build best practices

AWS: Skill Builder + Well-Architected Framework + Builders' Library

DevOps: GitHub Actions + Google SRE Books

Terraform: HashiCorp tutorials + live modular AWS infrastructure

ML Fundamentals: ISLP (with Python labs) + Google MLCC + scikit-learn MOOC

Deep Learning: PyTorch Basics + Understanding Deep Learning (Prince)

ML Engineering: Rules of ML + Hidden Technical Debt paper + MLflow

MLOps: Google MLOps CI/CD/CT Guide + MLOps Zoomcamp

Kubernetes: Official docs + Helsinki K8s MOOC + Amazon EKS Workshop

Observability: OpenTelemetry + Prometheus + Google SRE + Evidently AI

System Design (Continuous): DDIA 2nd Edition + Microsoft Cloud Design Patterns + Amazon Builders' Library + C4 Model

Frequently Asked Questions & Strategy

Engineering Pedagogy & Architecture FAQ

Direct answers to foundational questions about curriculum sequencing, systems prerequisites, textbook selection, and real-world engineering trade-offs.

What should I learn before distributed systems and system design?

Before diving into distributed consensus, partitioning, and replication, build an uncompromising foundation in Operating Systems internals (processes, threads, virtual memory, synchronization primitives, file systems, and socket calls via OSTEP) and Computer Networking (TCP flow control, 3-way handshake, DNS propagation, HTTP semantics via Beej's Guide).

Distributed systems are essentially collections of single-node operating systems communicating across unreliable networks. If you cannot explain how a single PostgreSQL process coordinates WAL flushes with fsync or how kernel socket buffers behave under load, analyzing distributed consensus algorithms becomes superficial memorization.

Why is this roadmap text-first rather than based on video playlists?

Text-based official documentation, RFC specifications, and canonical textbooks (such as ISLP, UDL, DDIA, and OSTEP) offer 5 to 10 times the information density of video tutorials. Text enables non-linear reference, rapid semantic search, and forces active mental model synthesis.

Video tutorials often induce a passive "illusion of competence" where students mimic typing code without developing debugging and architectural reasoning instincts. Professional software engineers spend their careers reading documentation and RFCs; learning to extract answers from dense text is itself an essential engineering skill.

How does this roadmap differ from roadmap.sh or generic bootcamps?

Most bootcamps and roadmap diagrams focus on frontend framework-chasing (HTML → React → Next.js) or generate dozens of disconnected "Hello World" repositories that leave learners unprepared for production environments.

The Wyrcan roadmap is built on One Evolving System and deliberate failure testing. Across the 12 stages, you incrementally architect, deploy, containerize, monitor, and scale a single production-grade AI platform. You deliberately inject faults (network latency, OOM crashes, data drift), trace them using OpenTelemetry and Prometheus, and document resolution in blameless postmortems.

Can I follow this engineering roadmap while working a full-time job?

Yes. We explicitly reject the fiction that comprehensive systems engineering can be mastered in an 8-week crash course. The curriculum provides an interactive Working Practitioner Track calibrated for 8–10 hours per week over 24 months (~8 weeks per milestone).

Each milestone divides neatly into 4 weeks of reading and lab problem sets, followed by 4 weeks of hands-on platform implementation and runbook authoring. For engineers on dedicated career sabbaticals, the Accelerated Sprint Track covers the identical scope in 12 months at 20–25 hours per week.

What concrete deliverables will I have in my portfolio by Stage 12?

By completing the curriculum, you will have built:

A hardened Linux microservice deployed behind Nginx with systemd service sandboxing.
Production multi-stage Docker containers with minimal distroless attack surfaces and isolated bridge networks.
Multi-tier AWS cloud infrastructure provisioned entirely with modular, remote-state locked Terraform.
Automated GitHub Actions CI/CD pipelines incorporating Trivy vulnerability scanning and zero-downtime deployments.
A custom-trained PyTorch neural network accompanied by MLflow experiment tracking and model registry lineage.
An automated continuous training (CT) promotion pipeline with canary routing gates and evidently-backed drift alarms.
A Kubernetes deployment orchestrated via Helm charts on AWS EKS or K3s.
Comprehensive OpenTelemetry distributed tracing, Prometheus metrics dashboards, and a simulated production incident postmortem.

70% Build

One System

Break Things

Design First

The Practitioner Standard

Choose Your Track (12 vs 24 Months)

Working Practitioner Track

Accelerated Sprint Track

0. Foundation Reset

Programming & DSA

Web, OS & Systems

Foundation Gate Criterion

0.6 PostgreSQL Tutorial & PGExercises

System Design Track

Architecture & Data

Reliability, Security & ML Systems

Linux & Networking

Learn

Production Deliverable

Docker Deeply

Learn

Production Deliverable

AWS Cloud Engineering

Learn

Production Deliverable

3.5 AWS Service Documentation

CI/CD & DevOps

Learn

Production Deliverable

4.5 Accelerate

4.6 Continuous Delivery

Terraform & IaC

Learn

Production Deliverable

Machine Learning Fundamentals

Learn

Production Deliverable

6.5 Hands-On ML with Scikit-Learn & PyTorch

PyTorch & Deep Learning

Learn

Production Deliverable

ML Engineering & MLflow

Learn

Production Deliverable

8.7 Designing Machine Learning Systems

MLOps Lifecycle & Pipelines

Learn

Production Deliverable

Kubernetes & EKS

Learn

Production Deliverable

10.6 Kubernetes: Up & Running (3rd Edition)

Observability & Production Engineering

Learn

Production Deliverable

11.7 Systems Performance (2nd Edition)

11.8 Implementing Service Level Objectives

11.9 Observability Engineering

Capstone Platform & Hardening

Integrate & Harden

Portfolio Package Deliverables

Final Portfolio Standard

The Non-Negotiable 13-Pillar Backbone

Engineering Pedagogy & Architecture FAQ