52 Weeks to
HFT Engineer
A Rust engineer's journey from frontend to low-latency trading infrastructure. One week at a time, building a full exchange from scratch.
Matching engine, binary protocols, SIMD optimizations, and everything in between. Every struggle documented. Every breakthrough shared.
Practice
Reading is the smallest part. These are where the weeks turn into skill.
Build one Rust exchange across the year. Week-gated tests and benchmarks run on your hardware and report here.
Spaced repetition over every concept check in the guides.
Latency numbers, memory-ordering litmus tests and spot-the-bug, eight at a time.
A 45-minute interview with an AI interviewer, scored on a rubric.
The reference matching engine compiled to WebAssembly, trading against simulated flow.
The Roadmap
4 phases. 52 weeks. From zero to a production-grade exchange in Rust.
Foundation
Concurrency, Memory & the Core Engine
Rust ownership as design, Tokio and structured concurrency, cache lines and lock-free queues — then the core of the exchange: order book, price-time matching, order types, an event-sourced journal, market data and binary encoding, checked by property-based tests.
Production
Gateway, Protocols, Risk & Resilience
Make it real: a TCP order gateway, FIX, pre-trade risk and throttles, market-data fan-out, persistence and recovery, observability, clocks, failover, simulation — ending in an end-to-end exchange under load.
Performance
Measure, Profile, Then Go Fast
Measure latency honestly, profile with perf and counters, remove allocations, redesign the book for the cache, SIMD, core pinning and busy polling, kernel networking, io_uring and kernel bypass, seqlocks, schema codecs, sharding and specialization — then a performance sprint against hard targets.
Mastery
Markets, Strategies & Getting Hired
Market microstructure, a market maker and a pairs strategy against your own exchange, backtesting, real-time PnL and risk, capture replay, deployment and chaos testing — then system design and deep-dive interview practice, the portfolio, and launch.
All 52 Weeks
Why This Exists
The HFT industry is one of the most secretive in tech. The existing literature on computational and technical aspects is limited — most cutting-edge research in latency improvements, code efficiency, and cache optimization remains behind closed doors.
I'm building this resource because when I started looking for a structured path from “interested in trading systems” to “employable at an HFT firm,” it didn't exist. There were scattered blog posts, expensive courses, and academic papers with no practical bridge.
This is my attempt to create that bridge. Everything is in Rust — the language I believe will increasingly challenge C++ in latency-critical systems. Every week is documented honestly: what worked, what didn't, what I'd do differently.
If even one person lands an HFT interview because of this project, it was worth building in public.