Hudson River Trading Interview Process (2026 SWE Guide)

The Hudson River Trading interview is a multi-stage process built for strong algorithmic candidates: a timed online assessment (commonly reported as HackerRank), one or two technical phone screens, and an onsite (often virtual) of four to six one-on-one rounds. What those rounds test depends on your track. Software Engineer and Core Developer loops lean on hard coding and, for Core, deep C++ and low-latency systems knowledge, while Algorithm Developer loops add probability, statistics, and expected value rounds.

HRT (Hudson River Trading) is a New York-based proprietary trading firm that trades its own capital on markets worldwide. Its production systems are mostly C++, its research stack is mostly Python, and its interviews reflect both.

Key Takeaways

• Pick your track before you prepare. Software Engineer, Core Developer, and Algorithm Developer share an OA style but split hard after the phone screen: systems depth for Core, math and statistics for Algo.
• The OA punishes untested code. Candidates consistently report that HRT's HackerRank assessment shows very few sample tests, so hidden edge cases decide your score.
• Core loops go deeper on C++ than FAANG ever does. Expect questions on cache lines, memory layout, allocation in hot paths, and lock-free concurrency.
• Algo Developer is a quant research interview. Expected value, conditional probability, Bayes, and Markov chains show up in phone screens and again onsite.
• Difficulty sits with Jane Street and Citadel, not below them. The flavor differs: HRT is more C++ and systems-heavy than Jane Street and less trading-game-heavy.
• Plan on four to eight weeks from application to offer, based on candidate reports.

What Are HRT's Engineering Tracks?

Candidates commonly describe three engineering tracks at HRT, and the interview you get depends on which one you apply to. Getting this wrong is the most common way strong candidates waste preparation time.

Software Engineer. Software Engineers build the tooling, infrastructure, simulation, and data platforms that researchers and traders depend on. The work spans C++ and Python, and the interview is closest to a hard big-tech loop with extra emphasis on correctness.

Core Developer (and low-level C++ roles). Core Developers work on the trading systems themselves, where code runs in the critical path between market data and order entry. HRT has also posted experienced low-level C++ engineering roles, which candidates say interview similarly. Expect C++ internals, performance reasoning, and concurrency on top of algorithms.

Algorithm Developer. Algorithm Developers build and test the predictive models behind trading, applying statistics to large amounts of market data. This is a quant researcher role with real programming expectations. The loop mixes coding with probability, statistics, and modeling questions.

If you are unsure, read the job description for the words "latency," "kernel," "networking," or "C++" (Core-leaning) versus "statistical," "models," or "research" (Algo-leaning). Track names on HRT's postings can change between hiring cycles, so confirm with your recruiter which loop you are in.

What Is the HRT Interview Process, Step by Step?

The HRT interview process has four stages for most candidates. Order and count vary by track and seniority, but the shape is consistent across public candidate reports.

1. Online assessment (OA). A timed coding test, commonly reported as HackerRank, with a few problems.
2. Technical phone screens (one or two). About 60 minutes each in a shared editor. Algo candidates often get one math-focused call and one coding call.
3. Onsite or virtual onsite. Four to six one-on-one interviews in a single day or split across two days.
4. Recruiter and fit conversations. Background, motivation, and team alignment, interleaved with the technical rounds rather than saved for the end.

Experienced hires sometimes skip the OA and go straight to a recruiter call and phone screen. New graduates and interns almost always take the OA first.

What Is on the Hudson River Trading Online Assessment?

The HRT online assessment is a timed coding test, commonly reported on HackerRank, and its defining feature is how little feedback it gives you. Candidates report that only a handful of sample test cases are visible, while the hidden tests probe edge cases you are expected to anticipate.

Problems typically run from LeetCode medium to hard. One recurring pattern in candidate reports is a data structure design problem: implement a class that supports several operations with specific complexity guarantees. These produce longer, stateful code where a single off-by-one error fails half the hidden tests.

How to approach it:

• Write your own tests before submitting. Empty input, a single element, duplicates, maximum constraints, negative numbers, and integer overflow.
• Read constraints first. If n reaches 10^5 or more, an O(n²) solution will time out on hidden tests even if the visible ones pass.
• Use 64-bit integers by default in C++ when sums or products could exceed about two billion.
• Keep design-problem code modular so you can test each operation in isolation.

Our online assessment tips guide covers time management and test-writing habits that transfer directly. If your pattern recognition is rusty, work through the coding interview patterns cheat sheet first, since HRT problems are often two patterns combined.

What Do the HRT Technical Phone Screens Cover?

HRT phone screens are about 60 minutes of live problem solving in a shared editor, and the interviewer cares about correctness and reasoning as much as speed. You will usually get one main problem with follow-ups that change constraints or ask you to optimize.

Software Engineer phone screens

Expect a medium-to-hard algorithms problem: graphs, intervals, heaps, or a design-a-structure question. Follow-ups usually ask about complexity, edge cases, and how your solution behaves at scale. Narrate your plan before coding; HRT interviewers want to see how you reason, and a silent correct answer earns less than a well-explained one. Our guide on how to think out loud in a coding interview has scripts for this.

Core Developer phone screens: C++ and low-latency topics

Core screens add C++ and systems questions on top of the coding problem. Topics candidates commonly report include:

• Memory layout of classes and structs, padding, and alignment
• Cache lines, false sharing, and why contiguous data beats pointer chasing
• Virtual memory, paging, and what happens on a page fault
• Cost of virtual dispatch, heap allocation, and exceptions in a hot path
• Amortized complexity of std::vector::push_back and when reallocation happens
• Move semantics, RAII, and undefined behavior
• Threads, atomics, memory ordering, and lock-free structures

A representative exercise is building a fixed-capacity single-producer, single-consumer ring buffer, then defending every design choice:

#include <array>
#include <atomic>
#include <cstddef>
#include <optional>

template <typename T, std::size_t N>
class SpscRing {
    static_assert((N & (N - 1)) == 0, "N must be a power of two");
    std::array<T, N> buf_;
    alignas(64) std::atomic<std::size_t> head_{0};
    alignas(64) std::atomic<std::size_t> tail_{0};

public:
    bool push(const T& v) {
        auto t = tail_.load(std::memory_order_relaxed);
        if (t - head_.load(std::memory_order_acquire) == N) return false;
        buf_[t & (N - 1)] = v;
        tail_.store(t + 1, std::memory_order_release);
        return true;
    }

    std::optional<T> pop() {
        auto h = head_.load(std::memory_order_relaxed);
        if (h == tail_.load(std::memory_order_acquire)) return std::nullopt;
        T v = buf_[h & (N - 1)];
        head_.store(h + 1, std::memory_order_release);
        return v;
    }
};

The follow-ups are the real interview. Why alignas(64) on the indices? (To keep producer and consumer counters on separate cache lines and avoid false sharing.) Why a power-of-two capacity? (A bitmask replaces a modulo.) Why acquire and release instead of sequentially consistent ordering? (It is the minimum ordering that publishes the write before the index moves.) If you cannot explain those trade-offs, review our C++ interview questions and concurrency and multithreading guide before the screen.

Algorithm Developer phone screens

Algo screens usually split into a math call and a coding call. The math call covers expected value, conditional probability, combinatorics, and brainteasers. A common way to prepare is Xinfeng Zhou's A Practical Guide to Quantitative Finance Interviews, often called the green book, which covers the classic question types.

What Does the HRT Onsite Look Like?

The HRT onsite (frequently a virtual onsite) is four to six back-to-back interviews of roughly 45 to 60 minutes each. Rounds go deeper than the phone screen, and each interviewer usually digs into a different area.

Treat this table as a planning default, not a guarantee; loops are adjusted per candidate and per team.

Core design rounds usually center on trading infrastructure rather than web scale. Plausible prompts include an order book that supports add, cancel, and best-price queries, a market data handler that parses a feed with minimal copying, or a logger that never blocks the hot path. The interviewer wants to hear about data structure choice, allocation strategy, and how you would measure latency.

Data analysis rounds for Algo candidates often give you a dataset or a described dataset and ask how you would find a signal, test whether it is real, and avoid overfitting. Expect to discuss train/test splits over time, lookahead bias, and statistical significance.

How Should Algo Developers Prepare for HRT Probability Questions?

HRT probability rounds test whether you can set up a problem cleanly and compute an exact answer under time pressure. The fastest path is structured practice on expected value, conditional probability, and geometric probability.

A practice problem in the style of quant probability rounds: two people each arrive at a uniformly random time within one hour, independently. The first to arrive waits 15 minutes, then leaves. What is the probability they meet?

1. Model arrivals as a point (x, y) in the unit square, where each axis is one hour.
2. They meet when |x − y| ≤ 0.25.
3. The complement is two corner triangles, each with legs of 0.75, so their combined area is 0.75² = 0.5625.
4. The probability of meeting is 1 − 0.5625 = 0.4375, or 7/16.

The follow-up is where the signal lives. Interviewers might change one person's wait time, or ask for the expected waiting time given that they meet. Say your setup out loud, check the answer at extreme values (a 0-minute wait gives 0, a 60-minute wait gives 1), and only then compute.

Topics to cover, in priority order:

• Expected value and linearity of expectation (including indicator variables)
• Conditional probability and Bayes' theorem
• Geometric probability on the unit square
• Markov chains and first-step analysis for "expected number of steps" questions
• Betting and EV games where you must choose an optimal stopping rule
• Basic statistics: variance, confidence intervals, and significance testing

If you are also interviewing at Jane Street, its market-making games add a betting and calibration layer that HRT uses less, so prepare those separately with our Jane Street interview guide.

How Does HRT Compare With Jane Street, Citadel, and Two Sigma?

HRT is generally regarded as top-tier in difficulty among quant firm interviews, alongside Jane Street and Citadel. The useful question is not which is hardest, but which loop rewards the skills you already have. Here is a triage scorecard, rated 1 (light) to 5 (heavy). The ratings are our own editorial judgment from public candidate discussion, not official data.

How to use the table:

• You are a systems or C++ engineer: prioritize HRT Core and Citadel. Jane Street will test skills you have not trained.
• You are a math-heavy competitive programmer: HRT Algo and Jane Street fit best.
• You are a strong generalist without deep C++: HRT Software Engineer and Two Sigma are better bets than HRT Core.

For the Citadel side of this comparison, including its HackerRank OA and exchange-flavored system design, see our Citadel interview guide.

How Much Does Hudson River Trading Pay Engineers?

HRT compensation is at the top of the market, and most of the variable upside comes through bonus rather than equity. HRT is privately held, so stock is not the main lever it is at public tech companies.

Public self-reported data, such as levels.fyi, suggests US new graduate software engineers at HRT report first-year total compensation roughly in the $350,000 to $500,000 range. That figure usually combines base salary, a sign-on bonus, and an annual performance bonus. Treat these as approximate and check current numbers yourself. Experienced engineers report substantially higher totals, with wide spread driven by bonus.

Two cautions. First, the sign-on bonus inflates year-one numbers, so compare year-two expectations too. Second, quant bonuses move with firm performance. Our salary negotiation guide explains how to compare a bonus-heavy quant offer against a big-tech equity package.

How Long Does the HRT Process Take, and Where Is It Based?

Most candidates report four to eight weeks from application to offer. The OA invitation arrives quickly; scheduling a full onsite panel is usually the slowest step. Campus hiring for new grads and interns runs early in the academic year, so apply as soon as postings open.

HRT is headquartered in New York and has offices in other cities, including international ones. Check the current job posting for the location and in-office expectations of your team.

A practical four-week plan if you have an HRT OA invitation: