Hudson River Trading Quantitative Researcher Interview Guide

From what candidates report, the single biggest reason people wash out of HRT's interview process isn't coding ability. It's statistics and probability. If you're coming from a CS background and plan to grind algorithm problems, you're preparing for the wrong fight.

Hudson River Trading Quantitative Researcher Role

Your job is to find, validate, and ship alpha signals across equities and futures that move real capital through HRT's automated trading systems. You'll prototype in Python, then pair with systems developers to translate winning signals into production C++ running inside HRT's low-latency pipeline. The research bar is exceptionally high: most signal candidates die in backtesting long before they see live capital, so your value in year one comes from iterating fast, killing bad ideas honestly, and demonstrating the rigor to get even one feature through HRT's internal simulation framework (which models realistic fills, latency, and transaction costs).

A Typical Week

The ratio of solo deep work to meetings is striking, but the real surprise is how much of your "coding" time isn't algorithm puzzles. It's pair programming with C++ devs to optimize cache behavior on your signal, or tracing a misaligned OPRA timestamp through HRT's internal data ingestion layer. You own the full research loop from tick data to internal wiki write-up, which is rare even among quant firms that claim flat structures.

Projects & Impact Areas

Mid-frequency signal research (minutes to hours, not microseconds) anchors the role. You might spend weeks building a nonlinear order-flow imbalance feature from queue position and trade-through data, then watch it fail out-of-sample. Execution quality work runs alongside alpha generation, where you model how strategies interact with order books to minimize slippage, and Friday cross-pod risk reviews force you to defend your model's behavior under tail scenarios in front of risk managers parsing aggregate portfolio exposures.

Skills & What's Expected

Business acumen is the skill most candidates underrate. HRT's interviews test finance intuition directly, and on the job you're expected to articulate why a signal works economically, not just that it backtests well. C++ and Python proficiency are expected per HRT's own mid-freq posting, and you'll work closely with engineers on production implementation even if you're not solely responsible for the trading code. Infrastructure and cloud ownership sit low on the priority list, though you still need to navigate HRT's internal data systems comfortably since pipeline proficiency matters at a working level.

Levels & Career Growth

HRT keeps titles flat, with no rigid Quant I, II, III ladder. Most new hires arrive with a PhD and start by contributing features to existing strategies before earning autonomy over a full signal pipeline. What separates levels is PnL impact and the willingness to kill losing ideas quickly rather than nursing them, a trait that from what candidates report, matters more than raw technical brilliance for advancement.

Work Culture

HRT operates more like a research lab than a bank, with a genuinely low-bureaucracy environment where you present directly to senior PMs. Researchers are in-office in New York, with arrivals around 7:00-7:30 AM and departures by 5:30-6:00 PM on typical days, though volatile markets stretch those hours significantly. The firm invests in custom hardware (they've blogged about verifying FPGA designs) and gives researchers real compute resources, which combined with small team sizes makes the day-to-day feel more like an academic group with actual stakes.

Hudson River Trading Quantitative Researcher Compensation

For non-partner roles, equity and RSUs are generally not part of the standard package. That means your comp structure is base salary plus a performance-based bonus, and from what the firm signals, that bonus can be a significant multiple of base. No vesting schedule to track, but also no equity upside to accumulate over time.

When negotiating, competing offers are your strongest card. The source data is clear that HRT weighs your "unique skills, research experience, technical prowess, and potential impact on trading strategies," so frame your case around those specifics rather than anchoring on base salary alone. Total comp is the number that matters here.

Hudson River Trading Quantitative Researcher Interview Process

The full loop runs about 7 weeks, which gives you breathing room but also creates a real risk of losing momentum. HRT's own blog says they intentionally avoid rushing candidates. Still, if a timeline concern comes up, raise it with your recruiter early, because HRT runs two separate coding rounds (Rounds 2 and 4), and that double-gate on implementation quality is unusual enough that rescheduling gets complicated.

From what candidates report, the Statistics & Probability round (Round 3) is where the most people wash out. That tracks with HRT's question distribution: 28% of interview content is stats and probability, the single largest category. If your prep has been mostly algorithm-focused, you'll likely hit a wall when asked to derive an estimator from scratch or work through a conditional expectation problem on a whiteboard with no code editor to lean on.

The behavioral round at the end isn't a cooldown lap. HRT's interview blog specifically calls out intellectual curiosity and comfort with being wrong as traits interviewers are trained to probe. Expect pointed questions about times your model failed, how you resolved disagreements with engineers, and what research problems you'd pursue if given a blank slate. Showing up with polished STAR stories but no genuine enthusiasm for the work itself won't get you through.

Hudson River Trading Quantitative Researcher Interview Questions

from collections import deque
from typing import List, Tuple, Optional


def vwap_1s_per_tick(trades: List[Tuple[int, float, int]]) -> List[Optional[float]]:
    """Compute 1s trailing VWAP for each tick.

    Args:
        trades: List of (ts_ns, price, size), sorted by ts_ns ascending.

    Returns:
        List of VWAP values aligned to input trades. If window volume is zero,
        returns None (should not happen if sizes are positive).

    Notes:
        Window is inclusive: keep trades with ts_ns >= current_ts - 1e9.
    """
    ONE_SEC_NS = 1_000_000_000

    # Deque holds (ts_ns, price, size)
    window = deque()

    # Use Python ints for exact accumulation.
    total_notional = 0.0  # sum(price * size)
    total_volume = 0      # sum(size)

    out: List[Optional[float]] = []

    for ts, price, size in trades:
        # Add new trade.
        window.append((ts, price, size))
        total_notional += price * size
        total_volume += size

        # Evict trades older than 1s trailing window.
        cutoff = ts - ONE_SEC_NS
        while window and window[0][0] < cutoff:
            old_ts, old_price, old_size = window.popleft()
            total_notional -= old_price * old_size
            total_volume -= old_size

        if total_volume == 0:
            out.append(None)
        else:
            out.append(total_notional / total_volume)

    return out


if __name__ == "__main__":
    # Simple sanity check
    ticks = [
        (1_000_000_000, 100.0, 10),
        (1_200_000_000, 101.0, 10),
        (2_100_000_000,  99.0, 20),
    ]
    print(vwap_1s_per_tick(ticks))

import numpy as np
import pandas as pd


def one_sec_log_returns_locf(timestamps_ns, mids):
    """Return (returns_series, frac_forward_filled).

    timestamps_ns: 1d array-like of int nanoseconds
    mids: 1d array-like of float midprices
    """
    df = pd.DataFrame({"ts": pd.to_datetime(pd.Series(timestamps_ns, dtype="int64"), unit="ns"),
                       "mid": pd.Series(mids, dtype="float64")})
    # Keep last mid for duplicate timestamps
    df = df.sort_values("ts").dropna(subset=["mid"])
    df = df.groupby("ts", as_index=False).last()
    df = df.set_index("ts")

    # Build fixed 1-second grid
    start = df.index.min().floor("S")
    end = df.index.max().ceil("S")
    grid = pd.date_range(start=start, end=end, freq="1S")

    # Align updates to grid using LOCF
    aligned = df.reindex(grid)
    had_update = aligned["mid"].notna()
    aligned["mid"] = aligned["mid"].ffill()

    # Forward-filled bins are those with no update but have a value after ffill
    forward_filled = (~had_update) & (aligned["mid"].notna())
    frac_forward_filled = float(forward_filled.mean()) if len(aligned) else np.nan

    # Log returns on grid
    logp = np.log(aligned["mid"])
    rets = logp.diff()
    rets.name = "log_return_1s"

    return rets, frac_forward_filled

import numpy as np
import pandas as pd


def rolling_signed_volume_imbalance(trades_df):
    """Compute 5-minute rolling signed volume imbalance on a 1-second grid.

    trades_df columns: ts (ns or datetime), price, size, side (+1/-1)
    Returns a pd.Series indexed by 1-second timestamps.
    """
    df = trades_df.copy()
    if not np.issubdtype(df["ts"].dtype, np.datetime64):
        df["ts"] = pd.to_datetime(df["ts"].astype("int64"), unit="ns")
    df = df.sort_values("ts")
    df["size"] = df["size"].astype("float64")
    df["side"] = df["side"].astype("float64")

    df["signed_size"] = df["side"] * df["size"]
    df = df.set_index("ts")

    # Aggregate to 1-second buckets, right-labeled so bucket time equals its right edge
    per_sec = df[["signed_size", "size"]].resample("1S", label="right", closed="right").sum()

    # Rolling sums over last 300 seconds inclusive of current second
    signed_roll = per_sec["signed_size"].rolling(window=300, min_periods=1).sum()
    vol_roll = per_sec["size"].rolling(window=300, min_periods=1).sum()

    imbalance = signed_roll / vol_roll.replace(0.0, np.nan)
    imbalance.name = "signed_volume_imbalance_5m"
    return imbalance

HRT's question mix rewards candidates who can start from a probability derivation and, without switching gears, land on a portfolio optimization or signal-weighting problem. That compounding difficulty between stats and modeling mirrors how the actual job works: your morning PnL review surfaces a distributional anomaly, and by afternoon you're reformulating an objective function to account for it. The prep mistake most likely to sink you isn't neglecting any single area, it's treating them as separate study tracks instead of practicing the handoffs between them, which is exactly what HRT's two-round coding structure and dedicated stats round are designed to expose.

Practice HRT-caliber questions across stats, modeling, ML, and finance intuition at datainterview.com/questions.

How to Prepare for Hudson River Trading Quantitative Researcher Interviews

HRT is expanding fast. The firm's 2025 trading revenue is on track for a record $12.3 billion, and it's pushing into new territory like market making on TP ICAP's Digital Assets Spot platform. For quant researchers, that means more instruments and more cross-asset signals to discover, backed by serious infrastructure (the team has written about verifying custom FPGA hardware designs in-house).

Most candidates fumble "why HRT?" by defaulting to prestige or name-dropping high-frequency trading. What actually works: anchor your answer to something specific, like the mid-frequency quant researcher role that blends deep statistical research with production C++ and Python, or HRT's expansion into crypto market making. A firm of roughly 1,150 people generating $12.3 billion in trading revenue is a very different environment from a multi-thousand-person megafund, and your answer should reflect that you've thought about what that ratio implies for the kind of work you'd actually do.

Try a Real Interview Question

from typing import Iterable, List, Tuple
import math

def ewma_mean_vol(returns: Iterable[float], lam: float) -> Tuple[List[float], List[float]]:
    """Compute EWMA mean and volatility for a sequence of returns.

    Args:
        returns: Iterable of returns r_t.
        lam: Decay factor lambda in (0, 1).

    Returns:
        A tuple (mus, sigmas) where mus[t-1] = mu_t and sigmas[t-1] = sigma_t.
    """
    pass

from typing import Iterable, List, Tuple
import math


def ewma_mean_vol(returns: Iterable[float], lam: float) -> Tuple[List[float], List[float]]:
    """Compute EWMA mean and volatility for a sequence of returns.

    Uses the recursions:
      mu_t = lam * mu_{t-1} + (1-lam) * r_t
      v_t  = lam * v_{t-1}  + (1-lam) * (r_t - mu_{t-1})^2
    with mu_0 = 0 and v_0 = 0, and sigma_t = sqrt(v_t).

    Args:
        returns: Iterable of returns r_t.
        lam: Decay factor lambda in (0, 1).

    Returns:
        (mus, sigmas) lists aligned to input order.

    Raises:
        ValueError: If lam is not in (0, 1) or returns contains non-finite values.
    """
    if not (0.0 < lam < 1.0):
        raise ValueError("lam must be in (0, 1)")

    mus: List[float] = []
    sigmas: List[float] = []

    mu = 0.0
    v = 0.0
    one_minus = 1.0 - lam

    for r in returns:
        if not math.isfinite(r):
            raise ValueError("returns must be finite")
        prev_mu = mu
        mu = lam * mu + one_minus * r
        diff = r - prev_mu
        v = lam * v + one_minus * (diff * diff)
        mus.append(mu)
        sigmas.append(math.sqrt(v))

    return mus, sigmas

HRT's own interview blog emphasizes that interviewers care about how you think through a problem, not just whether your code compiles. Their mid-frequency researcher posting lists both C++ and Python as requirements, so expect to write production-quality code in either language under time pressure. Build that muscle at datainterview.com/coding.

Test Your Readiness

HRT's engineering and interviewing blog makes clear they probe for genuine curiosity and willingness to be wrong, not just textbook recall. Sharpen your weak spots across all tested topics at datainterview.com/questions.