Engineering Manual

A structured course: foundations, implementation, operating systems, networks, security and architecture. Specialist labs are electives.

Start here: Amazon SDE II

This curated path prioritizes coding, maintainable design, databases, concurrency and system design before specialized infrastructure.

Computational foundations and data structures25 published chapters
Algorithm design and coding12 published chapters
Object design, SOLID and maintainability17 published chapters
Runtime, databases, networking and security32 published chapters
System design from requirements to failures10 published chapters
Optional: advanced distributed design and worked systems9 published chapters
Independent exercises and communication10 published chapters
Optional deeper compiler and VM foundations10 published chapters

Open the complete study path →

Study tracks

Computer Science — Core CurriculumA general prerequisite-led education with explicitly documented gaps.
Advanced Systems — Optional LaboratoriesInfrastructure and adversarial experiments after the core curriculum.

Unpublished topics remain explicit gaps; passing an automated test does not certify a chapter as technically complete.

Browse by category

Foundations of Computing (29)

Proofs, program semantics and computational reasoning.

Computer Architecture (5)

Bits, ISA, cache mapping and pipeline hazard models; coherence remains a gap.

Digital logic fundamentals: Boolean gates, truth tables and binary addersDerive AND, OR, NOT and XOR from truth tables and construct verified half-adders, full-adders and fixed-width addition.
Sequential logic fundamentals: clocked state, registers and finite-state machinesDerive clocked state transitions, D flip-flops, registers and finite-state machines with executable invariants and traces.
Machine Representation, CPU Instructions and Cache MappingDerive two's complement, endianness, ISA execution and direct-mapped cache conflicts with reproducible Python models and boundary tests.
CPU fundamentals: datapath, control and the fetch–decode–execute cycleTrace PC, accumulator, memory, ALU and branches using a bounded 8-bit instructional CPU with explicit instruction semantics.
CPU Pipelines: Data Hazards, Forwarding and Branch PredictionDerive instruction latency, throughput, stalls, load-use dependencies and two-bit branch prediction with independently tested pipeline models.

Data Structures & Algorithms (23)

Data representation, proofs and algorithms.

Operating Systems & Concurrency (10)

Processes, memory, threads and synchronization.

How programs run: command-line arguments, environment, streams and exit statusTrace a program invocation using C11 arguments, environment variables, stdout, stderr and subprocess tests.
Processes, Virtual Memory and System CallsDerive process isolation, virtual-address translation, page tables, TLBs, context switching, syscalls and protection guarantees.
Heap Allocation: Free Lists, Fragmentation and CoalescingModel first-fit and best-fit heap allocation, contiguous free blocks, external and internal fragmentation, splitting and coalescing with independent tests.
File Descriptors, Buffered I/O and fsync Crash BoundariesTrace open file descriptions, dup, shared offsets, read/write, buffering, fsync and crash recovery with independently verified Python models.
Filesystem Internals: Inodes, Block Allocation, Journaling and RecoveryModel inode identity, directory entries, noncontiguous block allocation and commit/replay crash boundaries with tested finite-state examples.
CPU Scheduling: FCFS, Round Robin, Response and FairnessDerive FCFS and Round Robin scheduling, preemption, arrival ties, turnaround and waiting with executable models and independent tick oracles.
Concurrency: Races, Locks, Conditions and DeadlocksDerive synchronization invariants, critical sections, race conditions, condition-variable protocols, deadlocks and bounded queues.
Priority Scheduling: MLFQ, Aging and Priority InheritanceDerive MLFQ scheduling, periodic priority boosts, starvation and lock priority inheritance with independently verifiable models.
Memory Models: Atomics, Happens-Before and VisibilityExplain C++ data races, per-object modification order, release/acquire, relaxed operations, sequential consistency and publication safety.
C++17 Engineering Workshop: Thread-Safe Token Bucket and CIBuild and test a native C++17 token bucket with steady clock injection, mutex invariants, input validation and compiler-backed CI.

Computer Networks (7)

IPv4 prefix routing and DNS cache fundamentals; transport mechanics remain to expand.

HTTP fundamentals: requests, responses, methods and client-server boundariesUnderstand web requests, status codes, GET/POST/PUT/DELETE semantics and basic API responsibilities before advanced system design.
IP Routing and DNS: Prefix Selection, Resolution and TTL CachesDerive IPv4 longest-prefix routing and DNS resolver caching, record TTL expiry and failure semantics with independent Python test oracles.
IP Packet Size: IPv4 Fragmentation and Path MTU DiscoveryDerive the 8-byte IPv4 fragment offset, MF/DF semantics, ordered reassembly, and classical PMTUD under explicit finite models.
DNS Authority, CNAME Chains and Negative CachingDerive DNS zone authority, recursive referrals, CNAME chains, NXDOMAIN/NODATA cache keys and SOA-based negative TTLs with independent tests.
Networking Fundamentals: DNS, TCP, TLS and HTTPTrace a web request through DNS, transport, TLS and HTTP; derive latency and failure budgets and distinguish TCP from QUIC.
TCP Byte Streams: Message Framing, ACKs and Flow ControlDerive TCP stream framing, relative sequence numbers, cumulative acknowledgments and sender windows using independently verified Python models.
TCP Retransmission Timers: RTT Estimation, Karn's Rule and Congestion WindowsDerive RFC 6298 SRTT/RTTVAR/RTO and backoff, then distinguish a simplified cwnd/ssthresh round model from actual TCP Reno.

Security & Cryptography (3)

Security protocols; cryptographic foundations still missing.

TLS 1.3: Handshake Authentication, HKDF and Traffic KeysTrace TLS 1.3 authentication and key derivation, distinguish HKDF from encryption, and verify HKDF-SHA256 and TLS labels against standard vectors.
API Security: Identity, Authorization and Threat ModelsDistinguish authentication from object authorization, analyze OAuth and JWT boundaries, and derive tenant isolation and API threat controls.
OAuth 2.0 Security: PKCE, Token Binding and ReplayDerive the authorization-code PKCE flow, threat boundaries, refresh-token rotation, audience checks and replay resistance from IETF standards.

Software Engineering & Design (22)

OOP, SOLID, patterns, testing and quality.

Databases & Storage (8)

Queries, transactions, indexes and recovery.

Relational database fundamentals: keys, joins and data integrityDerive tables, primary and foreign keys, normalization and SQL joins from a small data model with executable constraints.
SQLite application fundamentals: parameterized CRUD and atomic transactionsBuild and test a small SQLite repository with bound parameters, constrained balances and transaction rollback.
SQLite schema migrations: user_version, compatibility and rollbackEvolve a SQLite database safely from two schema versions while preserving rows and rejecting inconsistent states.
Transactions, Isolation and Distributed ConsistencyDistinguish ACID isolation, serializability, linearizability, replication lag and practical consistency anomalies using explicit operation histories.
Transactional Indexes: MVCC, Uniqueness and Serializable IsolationExplain unique constraints under concurrency, multi-version indexes, predicate locking, write skew, isolation retries and indexing trade-offs.
SQL Query Planning: Selectivity, Statistics, Indexes and JoinsUnderstand SQL cost-based plans, cardinality estimation, composite indexes, join strategies and EXPLAIN ANALYZE with reproducible math.
Database Storage: Pages, MVCC, B-Trees and Write-Ahead LogsTrace tuple storage, B-tree page splits, MVCC version visibility and write-ahead crash recovery using documented PostgreSQL internals.
Database Replication, Failover and Data Loss BoundariesExplain WAL shipping, asynchronous and synchronous standby acknowledgments, replica lag, read consistency, retention slots and safe failover.

Distributed Systems (8)

Messaging, replication, coordination and resilience.

Caching: Correctness, Invalidation and FailureReason about cache-aside, TTL, stampedes, stale reads, hit rates and invalidation under explicit consistency and availability requirements.
Load Balancing: Capacity, Routing and Failure RecoveryDesign HTTP load balancing with explicit routing algorithms, quantitative capacity, health checks, failure budgets and retry safety.
Rate Limiting: Token Buckets and Distributed GuaranteesDerive token-bucket admission, compare counting windows, enforce HTTP 429 and discuss consistency, concurrency and failure handling.
Queues, Delivery Semantics and IdempotencyDesign asynchronous processing with at-least-once delivery, acknowledgments, dead-letter queues, retries, idempotent consumers and backpressure.
Data Partitioning and Sharding: Keys, Hotspots and RebalancingDesign partitions and shards from access patterns, quantify hotspots, model stable hashing, handle migration and global constraints.
Distributed Consensus: Raft, Quorums and Replicated LogsDerive quorum intersection and Raft terms, elections, log matching, commit rules, safety and limits during network partitions.
Network Partition Models: Exhaustive Quorum Connectivity ChecksEnumerate every undirected network graph for three and five voters, prove majority exclusivity, and identify untested partition behaviors.
Observability: Metrics, Logs, Traces and SLOsModel end-to-end latency, golden signals, trace propagation, SLO error budgets and high-cardinality pitfalls with tested calculations.

System Design (13)

Requirements, capacity, APIs and architectures.

Assessment & Engineering Judgment (11)

Exercises, design reviews and communication.

Specialized Systems Laboratories (11)

Elective infrastructure experiments.