A learning roadmap · in progress

Building engineering judgment

Follow along with what I'm doing and the resources I'm using to become better at decision making & problem solving as a Software Engineer. Building everything out in the open for anyone to see.

0 / 98 stages

Build · 0/5 courses

0 / 38 chapters

Reading · 0/4 books

0 / 22 items

Foundations

0 / 8

Decision logs

0 in rotation

Retention · 0 due · 0 streak

Build — CodeCrafters Reading — DDIA & more Foundations — NeetCode Judgment — decision log Retention — spaced review

Build — CodeCrafters

One milestone per course, taken to (pragmatic) completion, in order. Sub-checkpoints are the CodeCrafters stage-groups; each milestone ends in a capstone decision log.

Redis

Build a Redis server from raw sockets to replication — defend choosing an in-memory store over disk, and name exactly when that choice breaks.

0% +

Core server — TCP sockets, RESP, PING/ECHO, SET/GET, expiry 7 stages · ~11h

RDB persistence — read the snapshot file 6 stages · ~9h

AOF persistence — append-only log + replay 10 stages · ~15h

Replication — leader/follower handshake, command propagation 18 stages · ~27h

“RESP vs JSON for a wire protocol: what Redis traded away, and the workload where I’d make the opposite call.” not started ▸

1Prediction — before you read the answer

confidence %

2Confrontation — after the build

verdict

Logged

“RDB vs AOF: the durability/latency/recovery trade I’d default to, and the workload that flips it.” not started ▸

1Prediction — before you read the answer

confidence %

2Confrontation — after the build

verdict

Logged

“Single-leader vs multi-leader: where I draw the line, and what each costs.” not started ▸

1Prediction — before you read the answer

confidence %

2Confrontation — after the build

verdict

Logged

SQLite

Read a real SQLite database by hand — page headers, the B-tree, an indexed query — and predict which storage engine wins a query pattern before benchmarking.

0% +

Read the file format, walk the B-tree, run an indexed query 9 stages · ~14h

“B-tree vs LSM for this workload: which I’d reach for, and the read/write ratio that flips the call.” not started ▸

1Prediction — before you read the answer

confidence %

2Confrontation — after the build

verdict

Logged

HTTP server

Build an HTTP/1.1 server — requests, responses, headers, compression, keep-alive — and reason about encoding and evolution on the wire.

0% +

Base server — bind, parse requests, respond, headers, body 8 stages · ~12h

HTTP compression — gzip, multiple schemes 3 stages · ~5h

Persistent connections — keep-alive, concurrency, closure 3 stages · ~4h

“Versioning an API without breaking last year’s clients — the migration I’d never ship.” not started ▸

1Prediction — before you read the answer

confidence %

2Confrontation — after the build

verdict

Logged

DNS server

Build a DNS server — construct and parse the binary packet format, handle name compression, forward queries — and appreciate compact wire encoding.

0% +

UDP server — write/parse header, question, answer; name compression; forwarding 8 stages · ~12h

“Compact binary protocols: where DNS’s choices (name compression, UDP) pay off and where they bite.” not started ▸

1Prediction — before you read the answer

confidence %

2Confrontation — after the build

verdict

Logged

Kafka

Build a Kafka broker — the partitioned log, offsets, fetch and produce — and name the consistency model a system needs versus the one it secretly relies on.

0% +

Base — bind, correlation IDs, API versions 5 stages · ~8h

Concurrent clients 2 stages · ~3h

Listing partitions (DescribeTopicPartitions) 5 stages · ~7h

Consuming messages (Fetch from disk) 6 stages · ~9h

Producing messages (Produce records) 8 stages · ~12h

“Which consistency model a feature needs — and the one it’s secretly relying on.” not started ▸

1Prediction — before you read the answer

confidence %

2Confrontation — after the build

verdict

Logged

“Capstone: a published system-design writeup distilled from these decision logs.” not started ▸

1Prediction — before you read the answer

confidence %

2Confrontation — after the build

verdict

Logged

Reading — interleaved

Read ~1–2 chapters/week, interleaved with the builds: one "anchor" chapter (DDIA / Database Internals) plus one "light" read (A Philosophy of Software Design, then OSTEP). DDIA + APoSD finish within the build; the rest carries past it.

Designing Data-Intensive Applications

Martin Kleppmann

0/12 +

1. Reliable, Scalable, Maintainable Applications

2. Data Models and Query Languages

3. Storage and Retrieval

4. Encoding and Evolution

5. Replication

6. Partitioning

7. Transactions

8. The Trouble with Distributed Systems

9. Consistency and Consensus

10. Batch Processing

11. Stream Processing

12. The Future of Data Systems

Database Internals

Alex Petrov

0/14 +

1. Introduction and Overview

2. B-Tree Basics

3. File Formats

4. Implementing B-Trees

5. Transaction Processing and Recovery

6. B-Tree Variants

7. Log-Structured Storage

8. Introduction and Overview (Distributed)

9. Failure Detection

10. Leader Election

11. Replication and Consistency

12. Anti-Entropy and Dissemination

13. Distributed Transactions

14. Consensus

Operating Systems: Three Easy Pieces free

Remzi & Andrea Arpaci-Dusseau · Concurrency + Persistence parts only

0/7 +

C1. Concurrency — threads & locks

C2. Concurrency — condition variables & semaphores

C3. Concurrency — common bugs & deadlock

P1. Persistence — I/O devices & disks

P2. Persistence — files & directories

P3. Persistence — crash consistency (fsck/journaling)

P4. Persistence — log-structured file systems

A Philosophy of Software Design

John Ousterhout

0/5 +

1–3. Complexity & its symptoms

4–6. Modules should be deep

7–10. Information hiding & general-purpose design

11–16. Comments & naming

17–21. Consistency, obvious code, trends

Foundations — NeetCode

Course-first, then problems: finish the courses, then work NeetCode 150 pattern by pattern. The patterns line up with the builds (shown as ↔ hints).

Courses

Python for Coding Interviews 40 lessons

Algorithms & Data Structures for Beginners 35 lessons

Core Skills — implement the data structures 20 lessons

Advanced Algorithms (optional, later) 35 lessons

NeetCode 150 — patterns

Arrays & Hashing 9 problems ↔ Redis hash store

Two Pointers 5 problems

Sliding Window 6 problems

Stack 7 problems

Binary Search 7 problems ↔ SQLite B-tree

Linked List 11 problems

Trees 15 problems ↔ SQLite B-tree

Heap / Priority Queue 7 problems

Backtracking 9 problems

Tries 3 problems

Graphs 13 problems ↔ replication & partitioning

Advanced Graphs 6 problems

1-D Dynamic Programming 12 problems

2-D Dynamic Programming 11 problems

Greedy 8 problems

Intervals 6 problems

Math & Geometry 8 problems

Bit Manipulation 7 problems

Retention — spaced review

The other tracks ask "have I done it?" This one asks "do I still know it?" A card enters rotation once its milestone is checked off, then resurfaces on an SM-2 schedule. The count is public; the schedule is private.

0 cards in rotation · 28 authored

Build 0 Reading 0 Foundations 0 Judgment 0 Behavioral 0

Complete a milestone to put its cards in rotation.

Review 0 due · 0 day streak

Complete a milestone to put its cards in rotation.

All caught up.

build

Progress is shared — what you see is the live, saved state. The owner can unlock edit mode to check items off.