Phase 1 Months 1 – 6

Foundations

Build the floor that everything else stands on. C++ fluency, algorithmic thinking, Linux fundamentals, and the first taste of concurrency. At the end of this phase you should be getting initial screens — not offers, but screens. The goal is competence, not mastery.

01C++ Mastery
Core language & toolchain 8 tasks ▲
  • Install modern C++ toolchainGCC/Clang + CMake + VSCode or CLion. Get a consistent build environment first.
  • Complete a structured C++ courseLearnCPP.com is the go-to. Read every chapter, type every example. Do not copy-paste.
  • Learn RAIIResource Acquisition Is Initialisation. The single most important C++ concept. Understand it deeply before moving on.
  • Learn smart pointersstd::unique_ptr, std::shared_ptr, std::weak_ptr. Understand ownership semantics, not just syntax.
  • Learn move semanticsLvalues vs rvalues, std::move, move constructors, move assignment. This is where C++ diverges completely from TypeScript.
  • Learn STL containers and algorithmsvector, deque, map, unordered_map, set, priority_queue. Know the time complexity of every operation.
  • Learn memory managementStack vs heap allocation. new/delete (then never use them raw again). Memory layout. Alignment basics.
  • Understand undefined behaviourUB is a source of subtle bugs and security holes. Know the common cases: null dereference, out-of-bounds, signed overflow, strict aliasing.
HFT firms expect C++ fluency as table stakes. Interviews assume it. You cannot fake your way through a template metaprogramming question or memory model discussion. The fundamentals here unlock everything in later phases.
Resources
learncpp.com — free, comprehensive Effective Modern C++ — Scott Meyers cppreference.com
Build from scratch (C++ implementations) 6 projects ▼
  • Implement std::vector from scratchDynamic array, push_back, resize, iterator support. Use templates.
  • Implement std::unique_ptr from scratchOwnership transfer, custom deleters, move-only semantics.
  • Implement std::shared_ptr from scratchReference counting, control block, weak_ptr interaction.
  • Implement std::string from scratchSSO (small string optimisation) is optional but instructive.
  • Implement std::deque from scratchUnderstand chunked allocation. Why is it not contiguous?
  • Build a file parser projectRead structured data (CSV or binary), parse it, write results. Practical file I/O experience.
Implementing standard library types teaches you why they exist, not just how to use them. When an interviewer asks "how would you implement a smart pointer?", you will have done it — not described it theoretically.
02Algorithms & Data Structures
Core implementations 5 structures ▲
  • Implement hash table from scratchOpen addressing vs chaining. Load factor. Resize strategy.
  • Implement heap / priority queue from scratchMax-heap, min-heap. Heapify, sift-up, sift-down. Know why insert is O(log n).
  • Implement binary search tree from scratchInsert, delete, search, in-order traversal. Understand balance degradation.
  • Implement graph traversal (DFS + BFS)Adjacency list representation. Recursive and iterative DFS. BFS with queue.
  • Study complexity analysis (Big-O time + space)Not just memorising — derive the complexity of your own implementations. Amortised analysis matters.
Optiver specifically states "selecting the right data structure is a priority" in performance-critical code. You need to know why an unordered_map beats a map for your hot path, not just that it does.
LeetCode / NeetCode grind Target: 150–200 problems ▼
  • C++ only, alwaysNo TypeScript fallbacks. Every problem in the language you'll be interviewed in.
  • Pattern priority orderArrays/Hashing → Two Pointers → Sliding Window → Stack → Binary Search → Linked Lists → Trees → Heap → Graphs. Save DP for Phase 2.
  • The solve methodAttempt for 25 minutes. Stuck? Read the approach (not code). Solve from approach. Next day: delete and redo.
  • 1–2 problems per day, 7 days per weekConsistency matters more than intensity. 1 problem daily beats 10 problems on Sunday.
  • Weekly timed sessionsOne session per week where you solve 2 problems back-to-back under a timer. Practice the interview condition.
Resources
NeetCode.io — roadmap + videos LeetCode.com CSES Problem Set — theory grounding
03Linux & OS Fundamentals
Core OS concepts 6 topics ▲
  • Use Linux as your primary dev environmentDaily driver. Not WSL — a real Linux environment. You will find pain points that teach you things.
  • Processes vs threadsWhat is a process? What is a thread? What is the difference in memory layout? What happens on fork()?
  • Virtual memoryPage tables, address spaces, mmap, the difference between virtual and physical memory. Why can two processes have the same virtual address?
  • File descriptorsEverything in Linux is a file. stdin/stdout/stderr. open(), read(), write(), close(). Non-blocking I/O basics.
  • SignalsSIGTERM, SIGKILL, SIGINT, SIGSEGV. Signal handlers. Why you can't call malloc() in a signal handler.
  • Shell scriptingBash basics: loops, conditionals, file manipulation, process substitution. Write a build script. Automate something.
HFT systems run on bare Linux. You will be tuning kernel parameters, reading /proc, and understanding scheduler behaviour. This is not optional background knowledge — it is a direct interview topic at Optiver and IMC.
Resources
Operating Systems: Three Easy Pieces (free) The Linux Programming Interface — Kerrisk
04Concurrency — Introduction
Threading primitives & first projects 5 tasks ▲
  • Learn std::threadCreating, joining, detaching. RAII thread wrapper (std::jthread in C++20).
  • Learn std::mutex and lock typesstd::lock_guard, std::unique_lock, std::scoped_lock. Deadlock conditions. RAII locking.
  • Learn std::condition_variableSpurious wakeups. The wait-with-predicate pattern. Producer-consumer coordination.
  • Implement: Producer-consumer queueBounded queue with mutex + condition variable. Get it right — race conditions are subtle. Add unit tests.
  • Implement: Thread poolFixed-size worker thread pool. Task queue. Graceful shutdown. This is a classic interview project.
Concurrency is where C++ developers get hurt. Understanding the primitives at this level is a prerequisite for lock-free programming in Phase 3. You cannot skip the mutex era.
Resources
C++ Concurrency in Action — Anthony Williams CppCon: "Back to Basics: Concurrency"
05Math & Probability — Start Here
Probability foundations 1 chapter per 2–3 weeks ▲
  • Conditional probability and Bayes' theoremP(A|B). Bayesian updating. The classic Monty Hall problem. Understand why intuition fails here.
  • Expected value and varianceE[X], Var[X]. Linearity of expectation. Why E[X²] ≠ E[X]². Covariance.
  • Common distributionsBernoulli, Binomial, Geometric, Poisson, Normal, Uniform. Know the PDF, mean, and variance of each.
  • Combinatorics basicsPermutations, combinations, the multiplication rule. Counting arguments are the basis of many brainteasers.
  • First brainteasers (2–3 per week)"How many times does a clock's hands overlap in a day?" "Expected number of coin flips to get HH?" Work through these in writing.
Optiver and IMC filter SWE candidates on probability puzzles. This is not optional for the quant track. One chapter every 2–3 weeks is sustainable alongside everything else — slow is fine, understanding is mandatory.
Resources
Introduction to Probability — Blitzstein & Hwang (free PDF) Fifty Challenging Problems in Probability — Mosteller TraderMath.org — quant interview practice
06WBD — Day Job Leverage
Turn your job into your best CV bullet 2 objectives ▲
  • Find a latency problem in the search serviceProfile it. Use distributed tracing, APM tools, or manual instrumentation. Understand where time is being spent.
  • Own the fix end-to-end and instrument the improvementImplement the optimisation. Measure before and after. Write it up: "Reduced p99 latency from Xms to Yms by [specific change]." This goes on your CV verbatim.
One measurable performance improvement at a recognisable company like WBD is worth more to a quant recruiter than any side project. It proves you can find and fix real performance problems in production — exactly what they hire for.
07Interview Preparation
Phase 1 prep habits 3 habits ▲
  • 3–5 coding problems per weekOn top of your daily grind — at least one session under real timer conditions.
  • Learn common patterns explicitlyTwo pointers, sliding window, fast/slow pointer, merge intervals, cyclic sort, BFS/DFS templates. Know when to reach for each.
  • Verbalise your solutionsStart talking through your thinking out loud, even alone. Coding silently and coding while explaining are completely different skills.
Milestone — End of Month 6

You should be able to: Code fluent modern C++ without referencing syntax. Solve medium LeetCode problems in C++ within 30 minutes. Explain what RAII, move semantics, and virtual memory mean. Write a thread pool from memory. Solve basic probability puzzles. Have one performance win at WBD on your CV. At this point you may start getting initial interview screens — that is the target for phase 1.

← Back Overview Next → Phase 2: Systems & Performance