SDE Interview Prep

A single, opinionated knowledge base for going from junior engineer to distinguished engineer, with dedicated tracks for quantitative development, ultra-low-latency trading systems, and agentic AI. It is part curriculum, part reference vault, part runnable code. It has been built and maintained continuously since 2021.

Author: Shreejit Verma (@shreejitverma) License: MIT

Roughly 15,000 tracked files. Most of the value is in the code and the long-form notes, not in this README. Every knowledge note carries typed frontmatter (type, track, level, status), and every folder has an entry note, so the vault can be browsed from any folder or queried with Dataview.

1. Read 00-Start-Here/Roadmap.md for the overall path.
2. In Obsidian, open 00-Start-Here/Vault-Map.canvas for the same path as a clickable map, and 00-Start-Here/How-This-Vault-Works.md for how the notes, diagrams, and review queue fit together.
3. Copy 00-Start-Here/Checklist.md and track your progress against it.
4. Use INDEX.md as the phased table of contents.
5. Pick a track below based on your target role.
6. Work the Review queue: notes come due by status and last review date.

• General SDE (FAANG-style): 01 -> 03 -> 04 -> 06.
• Quant developer / HFT C++: 02/C++ -> 03/04-Gold-Standard-Cpp-Patterns -> 05 -> 14 -> 12.
• Quant trader or researcher, or the finance side of quant dev: The-Quant-Prep, the companion repo for probability, pricing, market making, alpha research and firm preparation.
• Senior / staff / distinguished: 04 -> 08 -> 09 -> 10 -> 11.
• AI / agent engineering: 13, then 04 for the production side.

00-Start-Here/                 Roadmap and progress checklist
01-CS-Foundations/             OS, Networks, DBMS, OOP (with C++ concurrency and socket code)
02-Programming-Languages/      C++, Python, Java, JavaScript
03-Data-Structures-Algorithms/ Topic-wise solutions, LeetCode, gold-standard C++ patterns
04-System-Design/              Concepts, LLD, HLD case studies, design patterns
05-Quantitative-Finance/       Mathematics, quant dev (C++), algo trading (Python)
06-Interview-Prep/             Behavioral, resume, mock interviews
07-Project-Portfolio/          Portfolio project ideas (README.md)
08-Distinguished-Engineering/  Concurrency, distributed systems, DB internals, architecture
09-Engineering-Leadership/     Technical writing, mentorship, code review
10-Development-Practices/      Testing, CI/CD, cloud-native
11-Security-And-Cryptography/  Secure coding, common vulnerabilities
12-Performance-Engineering/    CPU architecture, profiling
13-Agentic-AI/                 Agentic AI: Zero to Godhood (14 volumes), harness docs, interview prep
14-Low-Latency-Systems/        Low-latency trading systems vault (Obsidian)
15-Technical-Whitepapers/      Technical whitepapers archive (eBPF, Memory, Kernels, Exploitation, Hardening)
16-Interview-Command-Center/   Obsidian mission control: role hubs, templates, macros, dashboards (private data symlinked in)
INDEX.md                       Phased table of contents with direct links
CS-Subjects/                   Legacy index that now points into 01-CS-Foundations
tools/                         Vault audit, link repair, and guard scripts (see tools/README.md)

Operating systems, computer networks, DBMS, and object-oriented programming. Not just notes: there is working code for the concepts that interviewers actually probe.

• Concurrency in C++: producer-consumer and synchronization primitives.
• Socket programming in C++: a TCP server from socket() up.

The two flagship guides are written as full books, with LaTeX and PDF builds checked in.

• C++ Zero to Godhood: the complete evolution of the language, C++98 through C++26, with a mindmap and a compiled PDF.
• Python Zero to Godhood: generators, decorators, async, quant libraries.
• C++ STL complete reference: every container, algorithm, and complexity in one table.
• Ultimate C++ Advanced Guide and Ultimate C++ Design Patterns.
• Blind 75 and NeetCode 150 solved in C++ and Python.
• Java, JavaScript.

About 3,500 C++ and 3,300 Python files, organized by pattern under 01-Topics: arrays, strings, linked lists, stacks and queues, trees, tries, graphs, heaps, hashing, DP, backtracking, greedy, divide and conquer, branch and bound, bit manipulation, geometry, mathematics.

• Gold-standard C++ patterns: modern C++20 reference implementations across fundamental data structures, graph algorithms, DP paradigms, string matching, and number theory.
• LeetCode Solutions Master Dashboard: complete Blind 75 progression matrix with standalone runnable implementations across 6 languages (C++, Python, Java, TypeScript, Go, Rust) and 4-tier deep dive notes.
• Blind 75 must-do LeetCode.
• LeetCode solutions and guides.

• Concepts: CAP, sharding, caching, load balancing.
• LLD: SOLID principles and common problems.
• HLD case studies: URL shortener, rate limiter, real-time chat, distributed ID generator.
• Most Asked Design Questions: 80+ "Design X" problems (LRU cache, Twitter, skiplist, file system, underground system, web crawler) in both C++ and Python.
• Low Level Design: distributed cache, distributed event bus, rate limiter, service orchestrator.
• Design pattern catalogs: C++, Python, Java.
• InterviewReady reference material and the top-20 questions list.

• Option pricing: Black-Scholes and the Greeks.
• Monte Carlo: option pricing by simulation.
• Order book in C++ and a memory pool.
• Event-driven backtester and strategies (mean reversion, Bollinger bands).

Small, complete implementations of the things senior interviews go deep on (section index).

Related: false sharing and a memory leak demo for profiling practice in 12.

A 14-volume curriculum ordered as a dependency graph: LLM foundations, working with LLMs, tool use and the agent loop, agent architectures, RAG, memory and context engineering, multi-agent systems, frameworks and SDKs, Model Context Protocol, evaluation and observability, safety and security, production engineering, coding agents and computer use, and frontier capstones. Appendices include a glossary, paper list, benchmark index, interview drills, and a pattern library. Agentic Harness documents a personal multi-agent engineering harness (architecture, lifecycle, model routing, safety gates) with an interview kit. Agentic AI Interview Prep is a 12-part question bank with model answers, tested code, and system-design walkthroughs.

An Obsidian vault (open the folder as a vault; start at 00 Home.md) covering the full stack of ultra-low-latency electronic trading:

market microstructure, exchange architecture, matching engine internals, hardware mechanical sympathy (caches, MESI, NUMA, TLB), OS and kernel tuning (isolcpus, nohz_full, IRQ affinity), kernel-bypass networking (Onload, DPDK), time and measurement (PTP, rdtsc, HDR histograms, coordinated omission), low-latency C++ (memory model, SPSC/MPMC rings, allocation-free loops), messaging and IPC (Disruptor, Aeron), protocols and codecs (ITCH, OUCH, MDP3/SBE, FIX), participant-side tick-to-trade pipelines, FPGAs, reliability and testing, and an industry map with canonical papers and talks.

Includes a 12-week production calibration roadmap and an interview question bank with answers.

Reading notes and an index for ~159 technical papers for systems programmers, performance engineers, and security researchers. The papers themselves are not stored here; 82 of them link to a legitimate public copy under their heading.

• Systems Performance & eBPF: the 14-paper Brendan Gregg canon (BPF superpowers, the USE method, flamegraphs, off-CPU analysis), plus syscall tracing overhead benchmarks.
• Operating Systems & Kernels: Dennis Ritchie's 1974 UNIX treatise, MIT's xv6 teaching OS, Nick Blundell's OS from scratch, the Linux scheduler wasted cores analysis, and the Windows NT Executive architecture.
• Memory Architecture & Concurrency: Ulrich Drepper's 114-page masterwork on caches, TLBs, and NUMA; the Ousterhout threading debate; and database join memory effects.
• Networking & Diagnostics: TCP Fast Open (0-RTT), Van Jacobson's netchannels, tcpdump/tcptrace analysis, and DDoS mitigation.
• Offensive Security & Exploitation: reverse engineering, stack buffer overflows, PE binary infection, advanced SQL injection (Chris Anley), and Same-Origin Policy bypasses.
• Defensive Security & Hardening: Michael Boelen's Linux hardening trilogy, container security (Docker, LXC, Chromium sandbox), and the OWASP ASVS standard.
• Polish Technical Papers (pl): 31 Polish research papers on ELF analysis, kernel rootkits, web security (Michał Sajdak), and SELinux.
• Developer Tooling: The AWK Programming Language (Aho, Kernighan, Weinberg) and Vim for humans.
• Seminal Computer Science Papers: 20 foundational papers spanning computability (Turing), information theory (Shannon), distributed consensus (Lamport, Paxos, Raft, FLP), cloud & big data (GFS, MapReduce, Bigtable, Dynamo, Spark), relational databases (Codd, Gray, Mohan ARIES), and Internet architecture (Cerf-Kahn, Saltzer, Van Jacobson).
• Seminal Low-Latency Systems Papers: 18 seminal papers for low-latency & HFT engineers covering C++ memory models (Boehm-Adve, McKenney), lock-free/wait-free algorithms (Herlihy, LMAX Disruptor, RCU), kernel bypass (Netmap, Stanford IX, RAMCloud), and market microstructure dynamics (Kyle, Glosten-Milgrom, Cont OFI, Stoikov Micro-Price, Budish, Avellaneda-Stoikov).

• 06 - Interview Prep: behavioral answers, resume guidance, mock interview checklists.
• 07 - Project Portfolio: portfolio project ideas by track.
• 09 - Engineering Leadership, 10 - Development Practices, 11 - Security and Cryptography, 12 - Performance Engineering.
• 16 - Interview Command Center: the Obsidian homepage; role hubs, macros, dashboards, and the review loop.
• CS-Subjects: a legacy index kept for old links; everything it lists lives in 01-CS-Foundations.

There is no single build system; each piece is self-contained.

# Any single-file C++ example
g++ -std=c++20 -O2 -Wall -Wextra -pthread \
  08-Distinguished-Engineering/01-Advanced-Concurrency/lock_free_stack.cpp -o lock_free_stack && ./lock_free_stack

# Any single-file Python example
python3 05-Quantitative-Finance/01-Mathematics/Option-Pricing/black_scholes.py

# C++ design patterns (CMake project)
cmake -S "04-System-Design/design-patterns-cpp" -B build && cmake --build build

# Python design patterns (has its own Makefile and tests)
cd "04-System-Design/design-patterns-cpp/python-patterns" && make

The Java projects under 04-System-Design use Maven (mvn test). The 14-Low-Latency-Systems and 13-Agentic-AI tracks are notes, not code, and read best in Obsidian.

• Do not read linearly. Pick a target role, follow the track above, and treat everything else as reference.
• For DSA, implement the gold-standard patterns from memory before opening the topic folders.
• For system design, write your own solution to a case study before reading the one here.
• For quant and low-latency, build the order book and memory pool yourself, then diff against the repo.
• The Checklist is a five-phase, ten-week plan. It works if you actually tick the boxes.

• tools/README.md lists the audit, link-repair, index, frontmatter, and style scripts; every editing script is a dry run unless given --apply.
• AUDIT.md is the generated health report (links, orphans, frontmatter, style, large files); regenerate it with python3 tools/audit_vault.py.
• CI runs the same checks on every pull request (.no-mistakes.yaml, .github/workflows/ci.yml): no broken links, no emojis or em dashes, no private data, and the tool tests.
• CLAUDE.md records the conventions: frontmatter schema, note standard, entry notes, archive folders, and the private-data rules.

Issues and pull requests are welcome, especially corrections to solutions, additional language ports, and new case studies. Keep the existing numbered directory layout, keep code self-contained and compilable, and see CODE_OF_CONDUCT.md.

Third-party books, course notes, and paid course material are never committed; link to the publisher or author instead. .gitignore blocks *.pdf except the vault's own Zero to Godhood books and openly licensed files.

MIT. Copyright (c) 2021 Shreejit Verma.