How to Get a Job at Radix Trading

Radix Trading is a high-frequency proprietary trading firm founded in 2017 and headquartered in Chicago. The firm is a spinoff from some of the most experienced talent in the HFT industry, and it has quickly established itself as one of the most technically sophisticated trading operations in the world. Radix trades across multiple asset classes using fully automated, ultra-low-latency systems that operate at the microsecond level.

What defines Radix is its relentless focus on technology-driven speed. The firm builds custom hardware and software to minimize the time between receiving market data and executing trades. This includes FPGA-based systems, custom networking stacks, kernel bypass techniques, and co-located infrastructure at major exchanges. Radix competes in the most speed-sensitive niches of electronic market making, where microseconds — even nanoseconds — of advantage translate directly to profits.

Radix operates with an extremely small team — estimated at under 100 employees — which means each person has outsized impact on the firm's performance. The firm maintains a very low profile, rarely appearing in industry press and providing minimal information about its strategies or operations. This secrecy is intentional: in HFT, revealing your approach invites competition. For candidates who want to work on some of the most challenging engineering problems in finance with a small group of exceptional peers, Radix represents one of the most compelling opportunities available.

Radix's culture is defined by engineering excellence and intellectual intensity. The firm attracts people who are passionate about solving hard technical problems at the limits of what's possible with modern hardware and software. Every engineer at Radix works on systems where performance matters at the nanosecond level — there is no room for mediocrity, and the standards are uncompromising.

The small team size creates a tight-knit, collaborative environment where everyone knows everyone else and individual contributions are highly visible. There's no bureaucracy or corporate overhead — decisions are made quickly by the people closest to the problem. This lean structure means you'll have significant autonomy and responsibility from day one, but it also means there's less formal mentorship or training compared to larger firms. Radix expects new hires to be largely self-directed and able to ramp up quickly.

The firm values deep technical expertise over credentials. What matters is your ability to understand systems at every level — from the physics of signal propagation through fiber optics to the details of CPU cache behavior to the mathematics of pricing models. Radix wants engineers who are genuinely obsessed with performance and who get satisfaction from shaving microseconds off critical paths. The work is intensely focused and technically rewarding, but candidates should be aware that the pace is demanding and the expectations are extremely high.

Radix hires for a small number of highly specialized roles, primarily in systems engineering, FPGA development, quantitative research, and network engineering. The common thread is exceptional technical depth — Radix wants people who are the best in the world at what they do.

For engineering roles, the firm looks for elite C++ programmers who understand performance optimization at every level of the stack. You need to understand CPU architecture (caches, branch prediction, pipelining), memory systems (NUMA, hugepages, memory-mapped I/O), networking (kernel bypass, DPDK, raw sockets), and how to write code that runs as fast as physically possible. Experience with FPGA development, hardware description languages (VHDL/Verilog), or custom hardware design is a major differentiator.

For research roles, Radix seeks candidates with strong mathematical foundations and the ability to develop models that operate under extreme constraints. Quant researchers at HFT firms need to think about problems differently than researchers at slower-moving firms — models must be simple enough to execute in microseconds while still providing predictive edge. A background in applied mathematics, physics, or electrical engineering is common among successful candidates. Above all, Radix wants people who are builders and tinkerers — people who understand systems from first principles and can innovate at the intersection of hardware and software.

Radix's interview process typically consists of 3 to 5 rounds over 3 to 6 weeks. The process is highly technical and focused on depth — Radix is evaluating whether you have world-class expertise in systems programming, low-latency engineering, or quantitative research.

The general structure is:

• Initial screen (1 round): A phone or video call with a senior engineer, typically lasting 45-60 minutes. This covers your background, technical interests, and includes probing questions about systems programming, C++ details, or relevant research. Radix uses this round to quickly assess whether you have the baseline depth for further evaluation.
• Technical deep-dive (1-2 rounds): Focused technical interviews that test your expertise in depth. For systems engineers, expect detailed questions about C++ internals, OS concepts, networking, and performance optimization. For researchers, expect mathematical and algorithmic problems. You may be given a take-home coding challenge involving performance optimization.
• On-site (2-3 rounds): Multiple interviews at Radix's Chicago office. These cover C++ coding (often optimizing a real system), systems design, mathematical reasoning, and cultural fit. Expect to write code on a whiteboard or laptop and discuss it in detail.

Radix's interviews go deeper than most firms on systems-level knowledge. Be prepared to discuss CPU microarchitecture, memory consistency models, compiler optimizations, and networking protocols at a level of detail that would surprise candidates at other firms. The firm is trying to find people who truly understand how computers work at every layer.

Each round of the Radix interview probes specific technical competencies at exceptional depth:

C++ and Performance Programming: This is the core of most Radix interviews. You might be asked to optimize a piece of code for cache efficiency, implement a lock-free data structure, explain what happens at the hardware level when a particular C++ construct executes, or reason about compiler optimizations. Questions often have layers — you'll write an initial solution, then be asked to make it 10x faster, then 10x faster again. Deep understanding of move semantics, template metaprogramming, SIMD intrinsics, and memory-mapped I/O is expected.

Operating Systems and Networking: Radix engineers work at the OS/hardware boundary. Expect questions about Linux kernel internals, scheduling, memory management, interrupt handling, and network packet processing. You should understand kernel bypass (DPDK, AF_XDP), TCP/IP at a low level, and multicast networking. Experience with real-time operating systems, CPU pinning, or NUMA-aware programming is a plus.

Mathematical and Algorithmic Reasoning: For quant roles, expect problems in applied math, optimization, and signal processing. Problems are often framed in the context of trading: how would you detect a signal in noisy data? How would you model market microstructure? For all roles, the ability to reason mathematically about system behavior (latency distributions, queueing theory, information theory) is valued.

Systems Design: You may be asked to design a component of a trading system — a market data handler, a matching engine, or a risk checking module — with extreme latency constraints. Radix evaluates your ability to make sound engineering tradeoffs under strict performance requirements. Every design choice should be justified with quantitative reasoning about latency impact.

Cultural Assessment: Radix is a small, intense team. Interviewers assess whether you'll thrive in an environment with high expectations, minimal hand-holding, and a relentless focus on technical excellence. Show passion for the craft of engineering, intellectual honesty, and the drive to continuously improve.

C++ is the language of Radix, and the firm expects a level of mastery that goes far beyond what most programmers achieve. You need to understand not just how to write correct C++ code but how the compiler translates it to machine code and how that code interacts with hardware.

Study "Effective Modern C++" by Scott Meyers, "C++ Concurrency in Action" by Anthony Williams, and "Computer Systems: A Programmer's Perspective" by Bryant and O'Hallaron. Practice implementing high-performance data structures: lock-free queues, memory pools, hash maps optimized for cache efficiency. Learn to use profiling tools (perf, VTune, cachegrind) to identify and fix performance bottlenecks.

Build projects that push performance boundaries: implement a simple matching engine, build a network packet parser, or write a market data feed handler. Benchmark everything and iterate on performance. The goal is to develop the intuition for what makes code fast — understanding branch prediction, instruction-level parallelism, memory access patterns, and SIMD vectorization at a visceral level.

Radix engineers operate at the hardware-software boundary, and interviews will test your understanding of the full stack from transistors to application code. Building this breadth of systems knowledge takes time but is essential.

Study operating systems fundamentals: "Operating Systems: Three Easy Pieces" (freely available online) covers the essentials. Then go deeper into Linux-specific topics: read about the kernel's memory management, scheduler, and network stack. Learn about kernel bypass networking (DPDK, AF_XDP) and understand why these approaches are necessary for ultra-low-latency applications.

Understand computer architecture at a practical level: CPU pipelines, cache hierarchies (L1/L2/L3), TLBs, memory controllers, and NUMA topology. Study how modern CPUs execute instructions out of order and how to write code that helps rather than hinders the branch predictor. If possible, experiment with FPGA development — even a basic project shows you understand hardware-software co-design.

Review Radix compensation data and book a coaching session with a Quant Blueprint mentor experienced in HFT preparation for targeted advice.

Radix's interviews are demanding and time-pressured. Practicing under realistic conditions helps you perform at your best when it matters.

Practice C++ coding problems on a whiteboard or in a plain text editor without IDE assistance. Radix may ask you to write and optimize code without syntax highlighting, auto-complete, or compilation — you need to be comfortable writing correct C++ from memory. Focus on problems involving performance optimization: given a working solution, make it 10x faster.

Prepare for deep technical discussions by reviewing your knowledge of systems fundamentals and practicing explaining complex topics clearly. An interviewer might ask "explain what happens when a packet arrives at the network card" and expect you to trace the path from NIC interrupt through kernel processing to userspace delivery, with detail about DMA, ring buffers, and context switching.

Mock interviews with other systems engineers or HFT candidates are invaluable. Focus on the back-and-forth nature of Radix interviews — interviewers will ask follow-up questions, propose constraints, and push you to go deeper. The ability to think on your feet and explore unfamiliar territory with intellectual honesty is what separates successful candidates from those who merely have strong fundamentals.