Learning Paths

Choose a route that fits what you want to build or understand: backend services, data systems, or the machinery behind a running program. Adjust the route as you go and skip material you already know.

Each path selects material from the 14 volumes for one goal. Check the prerequisites, complete the stage output, and return to a foundation chapter when you find a gap.

The time ranges are rough planning estimates. “Zero to First Job” names a learning goal and does not promise an employment outcome. Your background, weekly schedule, and exercise depth will change them. learning-paths.json provides the machine-readable path data.

Path	Audience	Time estimate	Final artifact
Zero to First Job	Students, self-taught beginners, and career changers	6–12 months	A small backend project with a database, HTTP API, tests, and deployment notes
Backend Engineer	Junior backend and application developers	3–6 months	A reviewable service implementation and design
Data and AI Engineer	Data analysts, data engineers, and developers moving into ML	4–8 months	A project from data preparation through model evaluation and serving notes
Systems Programmer	Developers moving into infrastructure, databases, compilers, or runtimes	6–10 months	A small interpreter, network service, or storage component
Software Architect	Senior engineers and technical leads	Ongoing	An architecture decision record with tradeoffs and an evolution plan
CS Interview Review	Candidates preparing for interviews or role changes	1–3 months	Topic-based problem reviews, design mocks, and an error map

Track 1: Zero to First Job

Outcome: Complete foundation-level development tasks, use the common toolchain, and choose the right layer when debugging.

Stage 1: Development tools

• Vol 0: Developer Workshop
• Study the terminal, Git, IDE debugging, package management, builds, and Docker.
• Checkpoint: clone a project, install dependencies, run its tests, set a breakpoint, and explain the contents of one commit.

Stage 2: Programming basics

• First program
• Control flow and recursion
• Arrays, classes and objects, and inheritance and polymorphism
• Strings, collections, exceptions, and file I/O
• Checkpoint: write a small program with input validation, collections, error handling, and file storage.

Stage 3: Data structures and systems foundations

• Complexity analysis and arrays and linked lists, followed by the hashing, tree, graph, and sorting chapters you need.
• Data encoding through CPU and ISA.
• Checkpoint: state the complexity of one data-structure operation and identify the CPU and memory layers involved in running a small program.

Stage 4: Networking foundations

• Network layers
• Socket programming
• TCP
• HTTP
• Checkpoint: trace one HTTP request across the application, transport, and network layers. Run a minimal client and server.

Stage 5: Database foundations

• SQL
• ER modeling and normalization
• B+ trees and storage engines
• Transactions and ACID
• MVCC and isolation levels
• Checkpoint: design a small schema, write reads and updates, then explain the roles of indexes, transactions, and isolation.

Stage 6: Backend project

• Software construction and testing strategies
• Review Docker and build and deployment.
• Final artifact: a small backend project with a database, HTTP API, automated tests, error handling, and deployment notes.

Track 2: Backend Engineer

Prerequisite: You can build a small service and understand collections, exceptions, file I/O, and basic SQL.

1. Networks and APIs: Study Computer Networking and API Design.
2. Data layer: Study Databases and Data Systems, with attention to query plans, transaction boundaries, isolation, caches, and messages.
3. Engineering quality: Use Testing Strategies and CI/CD and DevOps.
4. Distributed services: Start Distributed Systems with RPC, consensus, and storage. Continue into SRE, IaC, Kubernetes, and observability.

Produce a service design that covers the data model, transaction boundaries, caching or asynchronous work, failure handling, observability, and release flow.

Track 3: Data and AI Engineer

Prerequisite: You can process files and collections in one language and know basic algebra and probability.

Data and query preparation

• SQL
• Query execution and optimization
• Vol 12: Data Processing and Data Science

Vol 5 ch05–ch08 cover LSM trees, columnar storage, hash indexes, external sorting, and query optimization. Use Vol 12 ch09 for distributed batch and streaming data processing.

Mathematics and machine learning

• Use Vol 10: Mathematical Foundations to fill gaps in linear algebra, probability, and calculus.
• Study Machine Learning Foundations through Model Evaluation and Tuning.
• Continue with LLM Foundations and AI System Patterns.

Your final project should cover data cleaning, feature work, training, and evaluation. Document the serving approach, data boundaries, and known risks.

Track 4: Systems Programmer

Prerequisite: You know a systems language or plan to learn C, and you can read basic data-structure and network code.

1. Computer systems: Study Vol 3, with emphasis on memory, processes, concurrency, file systems, assembly, and calling conventions.
2. Compilers and languages: Use Compilers and Language Internals.
3. Networks and distributed systems: Study Computer Networking and Distributed Systems.
4. Performance: Connect Cache Hierarchies, CPU Pipelines, and Performance Engineering.

Implement a small interpreter, network service, or storage component. Explain its behavior with benchmarks, a profiler, or system counters.

Track 5: Software Architect

Prerequisite: You have shipped and maintained production systems. Use this path alongside the requirements work, incident reviews, and cross-team decisions in your real projects.

1. Architecture foundations: Study Software Engineering and Design Patterns and Domain-Driven Design.
2. Distribution and consistency: Use Distributed Systems and Data Consistency.
3. Security and governance: Study Security and Cryptography and Data Governance.
4. Observability: Read Observability and Observability in Depth.

For each study cycle, choose one system and write an architecture decision record. Include the requirements boundary, candidate designs, tradeoffs, consistency model, security, observability, migration steps, and rollback conditions.

Track 6: CS Interview Review

Outcome: Review the gaps that matter for your target role and use explanations to support problem practice.

Algorithms

• Cover complexity analysis, arrays and linked lists, hashing, trees, graphs, recursion, dynamic programming, and sorting.
• Choose problems by pattern. For each miss, record the wrong assumption, complexity, and reusable technique.

Systems, networking, and databases

• Systems: data encoding, CPUs, memory, processes and threads, plus the cache hierarchy.
• Networking: layers, TCP, HTTP, and DNS, CDN, and load balancing.
• Databases: SQL, normalization, B+ trees, transactions, and isolation levels.

System design and language fundamentals

• Distributed Systems Introduction, Raft, and Monoliths and Microservices
• Collections, Exceptions, and Concurrency Basics

Finish with a topic-based error map, timed coding sessions, and system design mock reviews. Set the quantity from the role and your current gaps.

Professional lookup

Topic	Direct links
HTTP request path	Network Layers · TCP · HTTP
TLS	HTTPS and TLS
DNS, CDN, load balancing	Vol 4 ch07
CPU caches and memory hierarchy	Vol 3 ch05
Virtual memory	Vol 3 ch06
Query optimizer	Vol 5 ch08
Transactions and isolation	Transactions · MVCC and Isolation
Raft	Vol 7 ch03
Observability	Foundation · In Depth
API design and DDD	API Design · DDD
Model evaluation	Vol 13 ch08

Reading across languages

Application chapters tend to use Java, with Python or C/C++ comparison sections. Computer systems chapters need C/C++ for the memory and machine model. Data and AI chapters often use Python. Follow the data model, state changes, and complexity before you compare syntax. You do not need three complete implementations for each concept.

Machine-readable paths

learning-paths.json lists stable IDs, audiences, outcomes, stages, time estimates, references, and assessment artifacts. npm run validate:docs checks each reference against the catalog. It cannot judge whether a path suits one learner or whether an article's technical claims are correct.