#+title: Interview Study Plan — Finance / HFT / Systems
#+date: 2026-04-22

* Target Firms
** HFT / Prop Trading
- Jane Street
- Citadel Securities
- Virtu Financial
- Jump Trading
- Optiver
- IMC
- Susquehanna (SIG)
- DRW
- Flow Traders
- Hudson River Trading

** Quant Hedge Funds
- Two Sigma
- DE Shaw
- Renaissance Technologies
- AQR
- Millennium Management

** Crypto Exchanges
- Coinbase
- Binance
- Kraken
- OKX

** Banks (Trading Desks / Strats)
- Goldman Sachs
- Morgan Stanley
- JP Morgan

** Fintech Infrastructure
- Broadridge
- ION Group
- Refinitiv / LSEG

* Study Tracks
** Track 1: LeetCode / Algorithms
- Arrays, hash maps, linked lists, stacks, queues
- Binary search, two pointers, sliding window
- Trees, graphs, DFS/BFS
- Sorting, heaps
- Dynamic programming (easy → medium)
- Math and probability puzzles (especially for Jane Street, Optiver)

** Track 2: Low-Level Systems
*** OS & Kernel
- Process vs thread, scheduling, context switching
- Memory management: virtual memory, paging, TLB
- System calls, interrupts
- CPU caching: L1/L2/L3, cache lines, false sharing
- NUMA architecture
- CPU pinning / thread affinity

*** Networking
- TCP vs UDP — congestion control, reliability, ordering
- KCP — low-latency UDP protocol
- Kernel bypass: DPDK, RDMA
- UDP multicast (common in market data feeds)
- FIX protocol basics

*** C++ Internals
- Memory model: stack vs heap, RAII
- Move semantics, copy elision, RVO
- Templates and template metaprogramming
- Undefined behavior and compiler optimizations
- SIMD intrinsics (basics)
- Custom memory allocators
- Lock-free data structures: CAS, atomics, memory ordering
- Ring buffers, lock-free queues

** Track 3: System Design
- General: scalability, load balancing, databases, caching
- Low-latency architecture patterns
- Co-location and proximity hosting
- Order book design and matching engine
- Market data feed architecture
- Tick-to-trade pipeline design

* Phased Timeline
** Phase 1 — Foundations (Weeks 1–3)
Goal: Build base knowledge across all three tracks simultaneously.

- [ ] LeetCode: arrays, hash maps, linked lists, stacks, queues (easy problems)
- [ ] Systems: OS fundamentals — processes, threads, memory management
- [ ] C++: review move semantics, RAII, memory model
- [ ] System design: read about scalability basics

** Phase 2 — Core Patterns (Weeks 4–7)
Goal: Pattern recognition in LeetCode; go deeper on low-level topics.

- [ ] LeetCode: binary search, two pointers, sliding window, trees, DFS/BFS (easy–medium)
- [ ] Systems: CPU caching, cache lines, false sharing, NUMA
- [ ] Networking: TCP/UDP deep dive, KCP
- [ ] C++: atomics, memory ordering, lock-free basics
- [ ] System design: practice 1 question/week (general scalability)

** Phase 3 — Advanced (Weeks 8–11)
Goal: Finance-specific systems knowledge; harder algorithm problems.

- [ ] LeetCode: heaps, graphs, DP, math/probability puzzles (medium–hard)
- [ ] Systems: kernel bypass (DPDK, RDMA), UDP multicast, CPU pinning
- [ ] C++: lock-free queues, ring buffers, custom allocators, SIMD
- [ ] System design: order book design, matching engine, market data feed
- [ ] Read about FIX protocol and tick-to-trade pipeline

** Phase 4 — Mock & Polish (Weeks 12+)
Goal: Interview simulation; fill gaps; stay sharp.

- [ ] Timed LeetCode sessions (medium difficulty, 45 min each)
- [ ] Mock system design interviews (1–2/week)
- [ ] Review flashcards daily (Anki)
- [ ] Company-specific prep: research each target firm's tech stack
- [ ] Behavioral stories in STAR format

* Resources
** LeetCode Lists
- Blind 75
- NeetCode 150
- Optiver / Jane Street past problem types (probability, brainteasers)

** Books
- "Computer Systems: A Programmer's Perspective" (CS:APP) — OS/memory
- "C++ Concurrency in Action" — lock-free, atomics
- "Designing Data-Intensive Applications" — system design
- "Trading and Exchanges" — market microstructure

** Online
- NeetCode.io — structured LeetCode patterns
- Martin Kleppmann's DDIA
- "What Every Programmer Should Know About Memory" (Ulrich Drepper)

* Weekly Rhythm
| Day | Focus |
|-----+-------|
| Mon | LeetCode (2–3 problems) |
| Tue | Low-level systems study |
| Wed | LeetCode (2–3 problems) |
| Thu | System design practice |
| Fri | C++ deep dive |
| Sat | Mock interview or review |
| Sun | Anki review + weekly reflection |