Citadel Quantitative Researcher Interview Guide

From what candidates report after their first year at Citadel, the biggest shock isn't the math or the hours. It's that your PnL is reviewed weekly in front of the portfolio manager, and there's no team average to hide behind. That directness is either the most motivating or most terrifying thing about the role, depending on your wiring.

Citadel Quantitative Researcher Role

You're building systematic trading signals that feed directly into live portfolios across equities, fixed income, commodities, and credit. The work spans the full lifecycle: sourcing alternative data, engineering features, backtesting in Citadel's proprietary framework with realistic transaction cost models, and writing production-grade Python and C++ that can survive real execution friction. After year one, the researchers who thrive are the ones who've demonstrated they can kill their own bad ideas as ruthlessly as they generate new ones.

A Typical Week

What the widget can't convey is the texture of that Monday strategy meeting. You're not giving a status update; you're defending signal performance with specific attribution numbers while your PM probes which factors decayed and why. The rest of the week is surprisingly solitary, mostly deep backtesting and feature engineering at your desk, punctuated by code reviews where teammates scrutinize each other's Python PRs for look-ahead bias and data leakage.

Projects & Impact Areas

Citadel's Global Quantitative Strategies group builds cross-asset macro models and factor timing signals spanning rates, commodities, and FX, while other research pods focus on single-name equity alpha using cross-sectional and time-series approaches. These aren't siloed academic exercises. Your signal's value is measured in PnL contribution, and because Citadel runs concentrated capital behind its highest-conviction strategies, even a modest Sharpe improvement on a well-sized book creates real dollar impact.

Skills & What's Expected

The coding bar is not a formality tacked onto a math interview. You'll write C++ kernels for computationally expensive rolling regressions and wrap them with Python interfaces for backtesting against years of tick data. What's underrated is business acumen: interviewers probe whether you understand slippage, capacity constraints, and market microstructure, because a signal that can't survive real execution costs is worthless regardless of its in-sample Sharpe.

Levels & Career Growth

Most external hires land at the Quantitative Research Analyst or Quantitative Researcher level. The promotion blocker that catches people off guard is regime robustness: Citadel's research culture demands that your alpha generation holds across different market environments, not just the one you happened to optimize for. Lateral moves between Citadel (the hedge fund) and Citadel Securities (the market maker) are possible but involve distinct PnL structures and research cultures.

Work Culture

Citadel requires five days a week in-office at their Miami headquarters, and they were among the most aggressive firms in mandating return-to-office. Expect 55 to 65 hour weeks as a baseline, with the pace set by Citadel's culture of relentless intellectual rigor where mediocre research simply doesn't survive PM review. The tradeoff is real, though: the caliber of colleagues is extreme, and the tight feedback loop between your research and actual market outcomes keeps people engaged long after the novelty wears off.

Citadel Quantitative Researcher Compensation

The bonus is where Citadel's comp gets interesting. Performance-based bonuses make up a substantial portion of total compensation and are heavily tied to both your individual results and the firm's overall performance. Because Citadel is private, there's no equity or RSU component, so the bonus structure carries the weight that stock grants would at a public company.

For negotiation, base salary and sign-on bonuses are where you have real room to push. The performance bonus structure is more standardized, so spend your energy elsewhere. Competing offers from top-tier quant firms or strong tech companies put you in the strongest position, and you should frame your case around total compensation and the specific value you'd bring to the firm's research efforts rather than haggling line by line. Practice building that narrative with questions at datainterview.com/questions.

Citadel Quantitative Researcher Interview Process

The timeline alone creates pressure. If you're interviewing in parallel with other quant firms, know that Citadel's pipeline is longer than most, and rounds don't always schedule back-to-back. The top rejection reason across all rounds is weak technical fundamentals, which at Citadel means probability, statistics, and coding are weighted roughly equally, so neglecting any one leg is a fast way out.

Round 8 is labeled "Bar Raiser," but don't map Amazon's version onto this. Citadel's final round pairs you with a senior leader or partner who pressure-tests your overall potential, strategic thinking, and depth across every technical area you've already been asked about. It's a genuine elimination round, not a culture conversation, and it can override strong performance in earlier stages if the senior interviewer isn't convinced you'll contribute to PnL on a multi-billion-dollar book.

Citadel Quantitative Researcher Interview Questions

from collections import deque
from typing import List, Tuple


def longest_band_interval(ticks: List[Tuple[int, float]], b: float) -> int:
    """Return the maximum number of consecutive ticks where max(mid)-min(mid) <= b.

    Args:
        ticks: List of (timestamp_ms, midprice), sorted by timestamp.
        b: Non-negative band size.

    Returns:
        Maximum length in ticks of any contiguous interval satisfying the constraint.
    """
    if b < 0:
        raise ValueError("b must be non-negative")
    n = len(ticks)
    if n == 0:
        return 0

    # Deques store indices, with mids monotone.
    # min_dq: increasing mids, front is min.
    # max_dq: decreasing mids, front is max.
    min_dq: deque[int] = deque()
    max_dq: deque[int] = deque()

    best = 0
    left = 0

    mids = [p for _, p in ticks]

    for right in range(n):
        x = mids[right]

        # Maintain increasing deque for mins.
        while min_dq and mids[min_dq[-1]] > x:
            min_dq.pop()
        min_dq.append(right)

        # Maintain decreasing deque for maxs.
        while max_dq and mids[max_dq[-1]] < x:
            max_dq.pop()
        max_dq.append(right)

        # Shrink until the band constraint holds.
        while min_dq and max_dq and (mids[max_dq[0]] - mids[min_dq[0]] > b):
            if min_dq[0] == left:
                min_dq.popleft()
            if max_dq[0] == left:
                max_dq.popleft()
            left += 1

        best = max(best, right - left + 1)

    return best


if __name__ == "__main__":
    data = [(0, 100.0), (1, 100.1), (2, 100.05), (3, 100.3), (4, 100.2)]
    print(longest_band_interval(data, b=0.15))  # expected 3

from typing import List, Tuple


def max_risk_penalized_subarray(returns: List[float], lam: float) -> Tuple[float, int, int]:
    """Maximize sum_{t=i..j} (r_t - lam * r_t^2) over contiguous subarrays.

    Args:
        returns: Daily simple returns r_t.
        lam: Risk penalty coefficient (can be 0).

    Returns:
        (best_value, start_idx, end_idx), where indices are inclusive.
        For empty input, returns (0.0, -1, -1).
    """
    n = len(returns)
    if n == 0:
        return 0.0, -1, -1

    # Transform each day into a score.
    x = [r - lam * (r * r) for r in returns]

    best_sum = x[0]
    best_l = best_r = 0

    curr_sum = x[0]
    curr_l = 0

    for i in range(1, n):
        # Either extend or restart at i.
        if curr_sum + x[i] >= x[i]:
            curr_sum += x[i]
        else:
            curr_sum = x[i]
            curr_l = i

        # Update global best.
        if curr_sum > best_sum:
            best_sum = curr_sum
            best_l = curr_l
            best_r = i

    return float(best_sum), int(best_l), int(best_r)


if __name__ == "__main__":
    r = [0.01, -0.02, 0.015, 0.005, -0.001]
    print(max_risk_penalized_subarray(r, lam=10.0))

import numpy as np


def rolling_zscore_log_return(midprice: np.ndarray, window: int, eps: float = 1e-12):
    """Compute leakage-free rolling z-scored 1-step log returns.

    Feature at time t is z-scored using the trailing window of returns ending at t.

    Parameters
    ----------
    midprice : np.ndarray
        1D array of midprices at 1-second frequency. Can include NaN.
    window : int
        Rolling window size in seconds (number of returns in the window).
    eps : float
        Small constant to avoid division by zero.

    Returns
    -------
    z : np.ndarray
        1D array, same length as midprice, z-scored log return feature.
        Invalid entries are NaN.
    valid : np.ndarray
        Boolean mask where the feature is valid.
    """
    x = np.asarray(midprice, dtype=float)
    n = x.size
    if window <= 1:
        raise ValueError("window must be >= 2")

    # Compute 1-step log returns safely.
    r = np.full(n, np.nan)
    finite = np.isfinite(x)
    # Avoid log of non-positive.
    pos = x > 0
    ok = finite & pos
    ok_prev = np.roll(ok, 1)
    ok_prev[0] = False

    idx = np.where(ok & ok_prev)[0]
    r[idx] = np.log(x[idx]) - np.log(x[idx - 1])

    # Rolling mean and std over trailing window ending at t.
    z = np.full(n, np.nan)
    valid = np.zeros(n, dtype=bool)

    # Use cumulative sums on a cleaned array to stay O(n).
    # We require all returns in the window to be finite to mark valid.
    r_f = np.where(np.isfinite(r), r, 0.0)
    is_fin = np.isfinite(r).astype(int)

    csum = np.cumsum(r_f)
    csum2 = np.cumsum(r_f * r_f)
    cfin = np.cumsum(is_fin)

    for t in range(n):
        start = t - window + 1
        if start < 1:  # need at least one return, and returns start at index 1
            continue

        # Window is r[start:t+1]
        s = csum[t] - (csum[start - 1] if start - 1 >= 0 else 0.0)
        s2 = csum2[t] - (csum2[start - 1] if start - 1 >= 0 else 0.0)
        k = cfin[t] - (cfin[start - 1] if start - 1 >= 0 else 0)

        if k != window:
            continue

        mean = s / window
        var = max(s2 / window - mean * mean, 0.0)
        std = np.sqrt(var)

        # z-score the current return r[t] using the window ending at t.
        if np.isfinite(r[t]) and std > eps:
            z[t] = (r[t] - mean) / std
            valid[t] = True

    return z, valid


if __name__ == "__main__":
    mp = np.array([100.0, 100.1, 100.0, np.nan, 100.2, 100.3, 100.25])
    z, mask = rolling_zscore_log_return(mp, window=3)
    print(z)
    print(mask)

import numpy as np


def _rankdata_average_ties(a: np.ndarray) -> np.ndarray:
    """Return 1..n ranks with average ranks for ties, NaNs preserved as NaN."""
    a = np.asarray(a, dtype=float)
    n = a.size
    ranks = np.full(n, np.nan)

    finite_idx = np.where(np.isfinite(a))[0]
    if finite_idx.size == 0:
        return ranks

    vals = a[finite_idx]
    order = np.argsort(vals, kind="mergesort")  # stable
    sorted_idx = finite_idx[order]
    sorted_vals = vals[order]

    # Walk runs of equal values.
    i = 0
    while i < sorted_vals.size:
        j = i
        while j + 1 < sorted_vals.size and sorted_vals[j + 1] == sorted_vals[i]:
            j += 1
        # Average rank for positions i..j in 1-based rank space.
        avg_rank = (i + 1 + j + 1) / 2.0
        ranks[sorted_idx[i : j + 1]] = avg_rank
        i = j + 1

    return ranks


def spearman_ic_by_minute(x: np.ndarray, r_next: np.ndarray, min_names: int = 5):
    """Compute per-minute Spearman rank IC and overall mean IC.

    Parameters
    ----------
    x : np.ndarray
        Shape (T, N) features at minute t.
    r_next : np.ndarray
        Shape (T, N) next-minute returns aligned so r_next[t] is r_{t+1}.
    min_names : int
        Minimum number of valid names required to compute IC for a minute.

    Returns
    -------
    ic_t : np.ndarray
        Shape (T,) IC per minute, NaN where undefined.
    mean_ic : float
        Mean IC over valid minutes.
    valid_minutes : np.ndarray
        Boolean mask over T.
    """
    x = np.asarray(x, dtype=float)
    r_next = np.asarray(r_next, dtype=float)
    if x.shape != r_next.shape or x.ndim != 2:
        raise ValueError("x and r_next must be 2D arrays with the same shape (T, N)")

    T, N = x.shape
    ic_t = np.full(T, np.nan)
    valid_minutes = np.zeros(T, dtype=bool)

    for t in range(T):
        xt = x[t]
        rt = r_next[t]
        ok = np.isfinite(xt) & np.isfinite(rt)
        if ok.sum() < min_names:
            continue

        rx = _rankdata_average_ties(xt)
        rr = _rankdata_average_ties(rt)
        # Restrict to valid names (ranks are NaN where invalid).
        ok2 = np.isfinite(rx) & np.isfinite(rr)
        if ok2.sum() < min_names:
            continue

        a = rx[ok2]
        b = rr[ok2]

        # Pearson correlation of ranks.
        a0 = a - a.mean()
        b0 = b - b.mean()
        denom = np.sqrt((a0 * a0).sum() * (b0 * b0).sum())
        if denom <= 0:
            continue

        ic_t[t] = float((a0 * b0).sum() / denom)
        valid_minutes[t] = True

    mean_ic = float(np.nanmean(ic_t)) if np.any(valid_minutes) else np.nan
    return ic_t, mean_ic, valid_minutes


if __name__ == "__main__":
    rng = np.random.default_rng(0)
    T, N = 4, 6
    x = rng.normal(size=(T, N))
    r = rng.normal(size=(T, N))
    x[0, 1] = np.nan
    r[2, 3] = np.nan
    x[1, :] = 1.0  # ties

    ic_t, mean_ic, vm = spearman_ic_by_minute(x, r)
    print(ic_t)
    print(mean_ic)
    print(vm)

What jumps out isn't any single category but how the quant-theory areas stack against everything else. Coding skill gets you through the door, but the prob/stats and modeling questions are where Citadel's process actually filters, because those rounds demand you derive results live, connect them to trading realities like transaction cost drag or signal decay, and then defend your assumptions under follow-up pressure. The biggest prep mistake? Spending most of your hours on algorithm drills because they feel productive, while underweighting the probability and ML modeling prep that Citadel's distribution clearly prioritizes for QR candidates.

Drill Citadel-style probability, modeling, and quant coding questions at datainterview.com/questions.

How to Prepare for Citadel Quantitative Researcher Interviews

Citadel LLC and Citadel Securities are separate entities, but interviewers at the hedge fund side expect you to understand both. Citadel Securities publishes year-end market commentary and market internals research that reveal how the broader organization thinks about liquidity, market structure, and execution quality. Reading those pieces gives you concrete talking points that most candidates never touch.

The "why Citadel" answer that actually works references the specific group you're joining. The EQR group builds systematic signals across equities, fixed income, commodities, and credit where researchers own code end-to-end, while the Global Quantitative Strategies team focuses on cross-asset macro models. Name which one excites you and why your past research maps to their problem space, because vague answers about "wanting to work with smart people" won't survive a bar raiser who's heard that pitch five hundred times this cycle.

Try a Real Interview Question

from typing import List
import math


def ewma_zscores(prices: List[float], lam: float) -> List[float]:
    """Compute EWMA volatility z-scores from a price series.

    Args:
        prices: List of prices p_0..p_{n-1}.
        lam: EWMA decay in (0, 1).

    Returns:
        List of z-scores z_1..z_{n-1}, one per log return.
    """
    pass

from typing import List
import math


def ewma_zscores(prices: List[float], lam: float) -> List[float]:
    """Compute EWMA volatility z-scores from a price series.

    We compute r_t = log(p_t / p_{t-1}) for t>=1 when both prices are valid and > 0.
    EWMA variance updates as sigma2_t = lam*sigma2_{t-1} + (1-lam)*r_t^2 with sigma2_0 = 0.
    z_t = r_t / sqrt(sigma2_t), and we output 0.0 if sigma_t == 0 or if r_t is invalid.
    """
    if not (0.0 < lam < 1.0):
        raise ValueError("lam must be in (0, 1)")

    n = len(prices)
    if n <= 1:
        return []

    out: List[float] = []
    sigma2 = 0.0

    def valid_price(x: float) -> bool:
        return isinstance(x, (int, float)) and math.isfinite(x) and x > 0.0

    for t in range(1, n):
        p_prev = prices[t - 1]
        p_cur = prices[t]

        if not (valid_price(p_prev) and valid_price(p_cur)):
            r = 0.0
            sigma2 = lam * sigma2
            out.append(0.0)
            continue

        r = math.log(p_cur / p_prev)
        sigma2 = lam * sigma2 + (1.0 - lam) * (r * r)
        sigma = math.sqrt(sigma2) if sigma2 > 0.0 else 0.0

        if sigma == 0.0:
            out.append(0.0)
        else:
            out.append(r / sigma)

    return out

Citadel's two separate coding rounds lean toward problems where financial intuition shapes your algorithm choice, not just asymptotic complexity. Sharpen that muscle at datainterview.com/coding, where you can filter for numerically intensive problems that mirror this style.

Test Your Readiness

Probability and statistics questions are where most candidates discover gaps too late. Stress-test yourself at datainterview.com/questions and let the results steer your remaining prep time.