Engineering Mastery Library

@amitmund July 09, 2026

Engineering Mastery Library

The Ultimate Roadmap of Roadmaps

A complete engineering curriculum covering Computer Science, Infrastructure, Cloud, DevOps, Platform Engineering, Security, AI, Distributed Systems, Software Engineering, and Leadership from Beginner to Distinguished Engineer / CTO level.

Level 0 — Computer Science Foundations

Computer Fundamentals Mastery

Computer Architecture
Digital Logic
Binary
CPU
GPU
Memory
Storage
Motherboard
BIOS
UEFI

Programming Fundamentals

C
Python
Go
Rust
Java
JavaScript
TypeScript

Algorithms & Data Structures

Arrays
Linked Lists
Trees
Graphs
Hash Tables
Dynamic Programming
Greedy
Divide & Conquer

Mathematics for Engineers

Linear Algebra
Statistics
Probability
Calculus
Graph Theory
Information Theory

Level 1 — Operating Systems

Linux Mastery
Linux Kernel Mastery
Linux Networking Mastery
Linux Security Mastery
Linux Performance Tuning
Linux Observability
Linux Filesystem
Linux Boot Process
Linux Memory Management
Linux Process Management
Linux Device Drivers
eBPF Mastery
System Programming

Level 2 — Networking

Networking Mastery
TCP/IP Deep Dive
HTTP Deep Dive
HTTP/2
HTTP/3
QUIC
DNS
DHCP
ARP
ICMP
TLS/SSL
VPN
WireGuard
BGP
OSPF
MPLS
VXLAN
EVPN
SDN
Load Balancing
Reverse Proxy
API Gateway
Service Mesh

Level 3 — Databases

PostgreSQL
MySQL
Redis
MongoDB
Cassandra
Neo4j
ClickHouse
Elasticsearch
OpenSearch
InfluxDB
TimescaleDB
Vector Databases

Level 4 — Storage

Filesystems
RAID
SAN
NAS
Object Storage
Ceph
MinIO
GlusterFS
Lustre
Storage Internals

Level 5 — Programming

Python Mastery
Go Mastery
Rust Mastery
C Mastery
Java Mastery

Level 6 — Software Engineering

Git
GitHub
Software Architecture
Design Patterns
Clean Code
SOLID
Refactoring
Testing
TDD
BDD
DDD
Clean Architecture
Hexagonal Architecture

Level 7 — DevOps

Docker
Kubernetes
Helm
Terraform
OpenTofu
Jenkins
GitHub Actions
GitLab CI
ArgoCD
FluxCD
Bash
Python for DevOps
Ansible
Packer
Vagrant

Level 8 — Platform Engineering

Internal Developer Platforms
Backstage
Crossplane
Golden Paths
Developer Experience
GitOps
Platform APIs
Self Service Platforms

Level 9 — Cloud

AWS
Azure
GCP
Multi Cloud
Hybrid Cloud
Cloud Native
FinOps

Level 10 — Observability

Prometheus
Grafana
Loki
Tempo
Jaeger
OpenTelemetry
ELK Stack
Fluentd
Fluent Bit
Vector

Level 11 — Security

Linux Security
Kubernetes Security
DevSecOps
IAM
OAuth2
OIDC
JWT
Vault
Secrets
PKI
Zero Trust
Supply Chain Security
Threat Modeling

Level 12 — Distributed Systems

CAP Theorem
PACELC
Consensus
Raft
Paxos
Gossip Protocol
Vector Clocks
CRDT
Leader Election
Service Discovery
Circuit Breaker
Saga
CQRS
Event Sourcing
Outbox Pattern

Level 13 — System Design

API Design
Microservices
Modular Monolith
Event Driven Architecture
Caching
Kafka
RabbitMQ
NATS
gRPC
GraphQL
REST
High Availability
Scalability
Capacity Planning

Level 14 — Performance Engineering

CPU Optimization
Memory Optimization
Profiling
Benchmarking
Flamegraphs
eBPF
io_uring

Level 15 — AI Foundations

Mathematics
Machine Learning
Deep Learning
Transformers
LLMs
Prompt Engineering

Level 16 — LLM Engineering

RAG
GraphRAG
MCP
AI Agents
Tool Calling
Long Context
Memory
Evaluation
Guardrails
AI Security

Level 17 — MLOps

MLFlow
Kubeflow
Ray
Airflow
Feature Stores
Model Registry
Drift Detection

Level 18 — Data Engineering

Spark
Flink
Kafka
Airflow
dbt
Iceberg
Delta Lake
Hudi

Level 19 — AI Infrastructure

GPU
CUDA
NCCL
Triton
vLLM
Ollama
Quantization
Distributed Inference

Level 20 — Cybersecurity

Kali Linux
Web Security
Network Security
Cloud Security
Malware
Reverse Engineering
Red Team
Blue Team
Purple Team
DFIR
Threat Hunting
SIEM

Level 21 — Hardware

CPU
GPU
Cache
NUMA
NIC
SmartNIC
DPU
NVMe
SSD Internals

Level 22 — Leadership

Technical Leadership
Team Leadership
Engineering Management
Project Management
Program Management
Product Thinking
Architecture Reviews
Design Documents
RFC Writing
Mentoring
Hiring
Career Growth

Level 23 — Principal Engineer Skills

Cross-Team Design
Organization-wide Architecture
Platform Thinking
Long-term Vision
Cost Optimization
Reliability Engineering
Technical Strategy
Technology Evaluation
Large Scale Migration
Engineering Economics

Level 24 — Distinguished Engineer Skills

Industry-wide Influence
Research Papers
Innovation
Standards
Protocol Design
Open Source Leadership
Large Scale Distributed Systems
AI Infrastructure
Company-wide Technical Direction
Architecture Governance

Level 25 — CTO Skills

Business Strategy
Product Strategy
Technology Roadmaps
Organization Design
Engineering Culture
Budget Planning
Vendor Management
Security Governance
Risk Management
Compliance
Executive Communication
Investor Communication
AI Strategy
Cloud Strategy

Missing Roadmaps I Would Still Add

These learning tracks complement the core Engineering Mastery Library and cover specialized domains required for Staff, Principal, Distinguished Engineer, AI Infrastructure Engineer, Security Architect, Platform Architect, and CTO-level roles.

Computer Science & Low-Level Systems

Compiler Engineering Mastery

Lexical Analysis
Parsing
Abstract Syntax Trees (AST)
Intermediate Representation (IR)
LLVM
Bytecode
JIT Compilation
AOT Compilation
Optimization Passes
Garbage Collection
Compiler Design Patterns

Operating System Internals Mastery

Boot Process
BIOS
UEFI
Linux Kernel
Windows Kernel
macOS Kernel
Process Scheduler
Memory Management
Paging
Virtual Memory
NUMA
Interrupts
System Calls
Device Drivers
Kernel Modules
IPC
cgroups
Namespaces

Programming Language Internals Mastery

Python Runtime
Go Runtime
Rust Ownership
JVM Internals
CLR Internals
JavaScript V8 Engine
Memory Management
Garbage Collection
Thread Scheduling
Coroutines
Async Runtime

Distributed Algorithms Mastery

Leader Election
Consensus
Paxos
Raft
Byzantine Consensus
Vector Clocks
Lamport Clocks
Chandy-Lamport Snapshot
CRDT
Distributed Locks
Distributed Transactions

Numerical Computing Mastery

Floating Point Arithmetic
SIMD
BLAS
LAPACK
Matrix Computation
Scientific Computing
GPU Computing
Parallel Algorithms

Cryptography Mastery

Symmetric Encryption
Asymmetric Encryption
Hash Functions
Digital Signatures
Certificates
PKI
TLS
SSH
Zero Knowledge Proofs
Homomorphic Encryption

Information Theory Mastery

Entropy
Compression
Error Detection
Error Correction
Coding Theory
Shannon Theory
Data Encoding

Infrastructure Engineering

Data Center Engineering Mastery

Data Center Design
Rack Architecture
Power Systems
UPS
Cooling
Fire Protection
Cabling
Spine-Leaf Networks
Physical Security

Enterprise Networking Mastery

Enterprise LAN
WAN
MPLS
SD-WAN
NAC
VLAN
VRF
QoS
Routing Design

Bare Metal Kubernetes Mastery

PXE Boot
MetalLB
Cluster API
kubeadm
Talos Linux
Flatcar Linux
High Availability
Bare Metal Networking

Storage Engineering Mastery

SAN
NAS
RAID
Ceph
GlusterFS
MinIO
Object Storage
NVMe
Filesystem Internals

Virtualization Mastery

KVM
Xen
VMware ESXi
Hyper-V
QEMU
Libvirt
Virtual Networking
Virtual Storage

Hypervisor Internals Mastery

Type-1 Hypervisors
Type-2 Hypervisors
CPU Virtualization
Memory Virtualization
IOMMU
SR-IOV
Nested Virtualization

OpenStack Mastery

Keystone
Nova
Neutron
Cinder
Glance
Swift
Heat
Horizon
Magnum

Proxmox VE Mastery

Cluster Setup
HA
Storage
LXC
KVM
Backup
Replication
Networking

Software Engineering

Refactoring Mastery

Code Smells
Refactoring Patterns
Legacy Code
Safe Refactoring
Testing Before Refactoring
Automated Refactoring

API Versioning Mastery

URI Versioning
Header Versioning
Semantic Versioning
Backward Compatibility
Deprecation Strategy

Feature Flag Mastery

Progressive Delivery
Canary Releases
A/B Testing
Rollback
Feature Management
Experimentation

Release Engineering Mastery

Release Planning
Build Pipelines
Deployment Pipelines
Artifact Management
Release Automation
Rollback Strategies

Software Delivery Mastery

SDLC
CI/CD
GitOps
Deployment Strategies
Release Governance
Deployment Automation

Technical Debt Management Mastery

Debt Identification
Debt Prioritization
Refactoring Roadmaps
Architecture Modernization
Risk Assessment

Platform Engineering

Backstage Mastery

Software Catalog
Templates
Plugins
Scaffolder
Developer Portal

Crossplane Mastery

Composite Resources
Providers
Infrastructure APIs
GitOps
Platform Automation

KCP Mastery

Multi-Tenancy
Workspace Management
Kubernetes Control Planes

Cluster API Mastery

Machine Deployment
Cluster Lifecycle
Infrastructure Providers
Bootstrap Providers

SPIFFE & SPIRE Mastery

Workload Identity
X.509 SVID
JWT SVID
Zero Trust Identity

Gateway API Mastery

Gateway
HTTPRoute
TCPRoute
TLSRoute
Policy Attachments

Service Mesh Internals Mastery

Istio
Linkerd
Envoy
Sidecars
Ambient Mesh
Traffic Policies

Artificial Intelligence & Machine Learning

AI Product Engineering Mastery

AI Product Design
AI UX
AI Lifecycle
Human Feedback
AI Governance

AI User Experience (AI UX) Mastery

Prompt UX
Conversational Design
Human-AI Interaction
Accessibility
AI Interfaces

AI Governance Mastery

Responsible AI
AI Policies
Compliance
Model Auditing
Risk Management

AI Compliance Mastery

GDPR
HIPAA
SOC 2
ISO 42001
AI Regulations

AI Ethics Mastery

Fairness
Bias Detection
Explainability
Responsible AI
Human Oversight

AI Benchmarking Mastery

MMLU
HumanEval
SWE-Bench
AgentBench
Custom Evaluations

Synthetic Data Engineering Mastery

Data Generation
Privacy Preservation
Simulation
Data Augmentation

Federated Learning Mastery

Edge AI
Distributed Training
Privacy
Secure Aggregation

Multi-Agent Systems Mastery

Agent Communication
Planning
Coordination
Negotiation
Emergent Behavior

AI Memory Systems Mastery

Short-Term Memory
Long-Term Memory
Episodic Memory
Semantic Memory
Memory Retrieval

Knowledge Graph Engineering Mastery

RDF
SPARQL
Ontologies
Neo4j
GraphRAG

Semantic Search Mastery

Embeddings
Hybrid Search
Vector Search
Re-ranking
Retrieval Optimization

AI Cost Optimization Mastery

Model Routing
Quantization
Caching
Batch Inference
Token Optimization

Cybersecurity

Binary Exploitation Mastery

Buffer Overflow
Heap Exploitation
Return-Oriented Programming
Format String Bugs

Secure Coding Mastery

OWASP Top 10
Input Validation
Secure APIs
Memory Safety

Mobile Security Mastery

Android Security
iOS Security
Mobile Reverse Engineering
Secure Mobile Apps

Cloud Forensics Mastery

AWS Forensics
Azure Forensics
GCP Forensics
Incident Response

Kubernetes Incident Response Mastery

Runtime Investigation
Pod Forensics
Audit Logs
Cluster Recovery

Container Escape Techniques Mastery

Namespace Escapes
Privilege Escalation
Kernel Exploits
Container Isolation

Secrets Management Mastery

HashiCorp Vault
AWS Secrets Manager
Azure Key Vault
GCP Secret Manager
SOPS

Hardware Security Module (HSM) Mastery

PKCS#11
Key Management
Secure Signing
Cloud HSM

Supply Chain Security Mastery

SLSA
Sigstore
Cosign
SBOM
Provenance
in-toto

Architecture & Design

Enterprise Architecture Mastery

TOGAF
Zachman
Business Architecture
Technology Architecture

Domain-Driven Design (DDD) Mastery

Aggregates
Entities
Value Objects
Bounded Contexts
Domain Events

Event Modeling Mastery

Event Storming
Event Flows
Event-Driven Design

Architecture Decision Records (ADR) Mastery

ADR Templates
Decision Logs
Trade-off Analysis
Governance

Evolutionary Architecture Mastery

Incremental Modernization
Fitness Functions
Continuous Architecture

Architecture Governance Mastery

Standards
Reviews
Architecture Boards
Technical Governance

Engineering Excellence

Engineering Metrics Mastery

DORA Metrics
SPACE Framework
Flow Metrics
Team Health

Incident Management Mastery

Incident Command
Severity Levels
Escalation
Communication

Postmortem Culture Mastery

Blameless Postmortems
RCA
Five Whys
Action Items

Chaos Engineering Mastery

Chaos Monkey
Fault Injection
Resilience Testing
Failure Simulation

Reliability Engineering Mastery

SLI
SLO
SLA
Error Budgets
Reliability Modeling

Capacity Engineering Mastery

Forecasting
Growth Modeling
Resource Planning
Scaling Strategies

Performance Testing Mastery

Load Testing
Stress Testing
Spike Testing
Soak Testing
Benchmarking

FinOps Mastery

Cloud Cost Optimization
Budgeting
Chargeback
Showback
Resource Optimization

Green Computing Mastery

Energy Efficiency
Carbon Footprint
Sustainable Infrastructure
Efficient Software Design