Citadel Data Scientist Interview Guide

From hundreds of candidate debriefs we've tracked at DataInterview, the single biggest mistake people make preparing for Citadel's data science loop is treating it like a big tech interview with a finance coat of paint. It's not. Your output here gets sized into trades, and the interviewers know the difference between someone who understands that and someone who doesn't.

Citadel Data Scientist Role

At Citadel, a data scientist works inside a small DS pod within the equities strategy group, sitting alongside quant researchers and presenting directly to portfolio managers who allocate capital based on your findings. Day to day, you're building features from alternative data (satellite imagery, credit card transactions, NLP on SEC filings), backtesting signals against real market data, and defending your methodology in rooms where nobody is polite about flawed assumptions. A strong first year means you've moved at least one signal from prototype into the live research pipeline with measurable attribution, not just delivered notebooks.

A Typical Week

The widget tells you where the hours go, but it can't tell you what "analysis" actually feels like here. A big chunk of that block is unglamorous deduplication work on messy vendor data, reconciling merchant category codes and hunting for artifacts that would make a signal look real when it isn't. The other thing candidates don't expect: when a satellite imagery vendor changes their API schema over the weekend and breaks your Kafka consumer feeding the feature store, you're the one patching the parser on GCP, not filing a ticket with a platform team.

Projects & Impact Areas

Signal discovery from alternative data feeds is the bread and butter. You might spend Tuesday morning writing heavy SQL with Spark to measure how quickly an earnings surprise signal decays across sectors, then pivot Wednesday to building supply chain graph features for a sector rotation model and running walk-forward backtests with full transaction cost modeling. Citadel Securities (the separate market-making arm) also hires data scientists, but the problems are different: you're optimizing spread capture and order flow toxicity rather than directional alpha, and the P&L dynamics don't translate directly.

Skills & What's Expected

The widget shows the scores. Here's what they mean in practice. The gap between candidates who pass and candidates who wash out almost always comes down to whether you can derive a result on a whiteboard and then explain to a PM why your backtest isn't overfit, not whether you know the latest architecture. Deep learning matters here (Friday mornings you might prototype transformer-based time series layers in TensorFlow), but Citadel interviewers will push you past the API into the underlying probability theory. "Business acumen" on the chart really means trading intuition: can you reason about Sharpe ratios, capacity constraints, and regime sensitivity without it sounding rehearsed?

Levels & Career Growth

Most external hires land at the mid-level, owning a research workstream end-to-end but operating within a PM's strategic direction. The jump to senior requires something specific: originating ideas that produce attributable results, not just executing well on someone else's research agenda. What tends to stall people, based on what candidates and former employees report, is less about technical depth and more about communicating uncertainty clearly during high-stakes readouts with PMs who want a straight answer on whether a signal is real.

Work Culture

Based on available data, Citadel maintains an in-office policy at its Miami headquarters five days a week, with most data scientists arriving by 7:30-8:00 AM and staying until 6:00-7:00 PM. Late nights around quarterly earnings or strategy reviews aren't unusual. Direct feedback is the norm: if your backtest methodology is flawed, a PM will tell you in the meeting, not in a gentle follow-up email.

Compensation is the retention lever. Citadel competes aggressively on pay to keep talent from jumping to firms like Jane Street or Hudson River, and the bonus ceiling for top performers has no cap. The pace is genuinely intense, but you'll learn more about applied quantitative research in one year here than in three at most tech companies.

Citadel Data Scientist Compensation

The bonus is where Citadel's comp gets interesting, and volatile. Performance-based bonuses are heavily tied to both individual and firm performance, often making up a large portion of total comp. The firm sometimes includes long-term incentives on top of base and bonus, though the specifics vary by role and team. That bonus variability is the key risk-reward calculation you're making versus a more predictable big-tech package.

Base salary has some room for negotiation, but the bonus structure is, from what the firm's offers suggest, more fixed around role, team, and market conditions. So focus your negotiation energy on demonstrating specific, high-impact skills (think: experience with noisy financial time-series or building research pipelines at scale) rather than trying to move the bonus multiplier. The source data is clear that articulating your potential impact on the team's research output is the strongest case you can make for a higher overall package.

Citadel Data Scientist Interview Process

Expect roughly 8 weeks from first recruiter call to offer, though candidates report that gaps between onsite rounds can stretch when teams are deep in quarter-end research cycles. Two dedicated coding rounds for a data scientist role is unusual, and it tells you something: Citadel treats shipping clean, efficient code as non-negotiable, not a nice-to-have on top of your stats chops.

The rejection reasons from candidate reports cluster around a few themes, not just one. Shallow statistical reasoning gets flagged often, but so does poor problem-solving structure (jumping to answers without clarifying assumptions) and an inability to articulate tradeoffs clearly. Citadel's behavioral round also carries more weight than its single-round presence suggests, because interviewers are screening for the drive and intellectual curiosity that fit a high-pressure trading environment where your analysis directly affects portfolio decisions.

Citadel Data Scientist Interview Questions

import numpy as np
import statsmodels.api as sm

def hac_mean_test(returns, max_lag=10):
    """HAC test for mean(returns) = 0 with Newey-West standard error."""
    r = np.asarray(returns)
    r = r[~np.isnan(r)]
    y = r
    X = np.ones((len(y), 1))
    model = sm.OLS(y, X).fit(cov_type="HAC", cov_kwds={"maxlags": max_lag})
    mean_hat = float(model.params[0])
    se_hat = float(model.bse[0])
    t_stat = float(model.tvalues[0])
    p_value = float(model.pvalues[0])
    return {
        "mean": mean_hat,
        "se_hac": se_hat,
        "t": t_stat,
        "p": p_value,
        "n": len(y),
        "max_lag": max_lag,
    }

from typing import List, Tuple


def rolling_net_signed_volume(trades: List[Tuple[int, str, float]], W: int) -> List[float]:
    """Compute net signed volume over the lookback window (t-W, t] for each trade.

    Args:
        trades: List of (ts_ms, side, qty), sorted by ts_ms (nondecreasing).
                side is 'B' or 'S'. qty is nonnegative.
        W: Window size in milliseconds.

    Returns:
        List of net signed volumes aligned to input trades.

    Notes:
        Window is open on the left, closed on the right: (t-W, t].
        Duplicate timestamps are included (all rows at ts == t are in the window).
    """
    n = len(trades)
    out = [0.0] * n

    def signed(side: str, qty: float) -> float:
        if side == 'B':
            return qty
        if side == 'S':
            return -qty
        raise ValueError(f"Invalid side: {side}")

    left = 0
    running = 0.0

    for i, (t, side, qty) in enumerate(trades):
        running += signed(side, qty)

        # Evict trades with ts <= t - W to enforce (t-W, t]
        cutoff = t - W
        while left <= i and trades[left][0] <= cutoff:
            lt, lside, lqty = trades[left]
            running -= signed(lside, lqty)
            left += 1

        out[i] = running

    return out


if __name__ == "__main__":
    # Simple sanity check
    trades = [
        (1000, 'B', 10),
        (1000, 'S', 3),
        (1500, 'B', 2),
        (2000, 'S', 1),
        (2500, 'B', 5),
    ]
    W = 1000
    # For t=2000, window is (1000,2000], so trades at 1000 are excluded.
    print(rolling_net_signed_volume(trades, W))

WITH dedup AS (
  -- Remove exact duplicate trade prints
  SELECT DISTINCT
    symbol,
    ts_utc,
    price,
    size
  FROM trades
), daily AS (
  -- Compute daily VWAP per symbol using UTC day boundary
  SELECT
    symbol,
    CAST(ts_utc AS DATE) AS trade_date_utc,
    SUM(price * size) AS notional,
    SUM(size) AS volume
  FROM dedup
  GROUP BY symbol, CAST(ts_utc AS DATE)
), ranked AS (
  -- Rank available trading days per symbol by recency
  SELECT
    symbol,
    trade_date_utc,
    notional,
    volume,
    DENSE_RANK() OVER (
      PARTITION BY symbol
      ORDER BY trade_date_utc DESC
    ) AS day_rank
  FROM daily
)
SELECT
  symbol,
  trade_date_utc,
  notional / NULLIF(volume, 0) AS vwap
FROM ranked
WHERE day_rank <= 5
ORDER BY symbol, trade_date_utc DESC;

WITH q AS (
  SELECT
    symbol,
    ts_utc,
    bid,
    ask,
    (bid + ask) / 2.0 AS mid
  FROM quotes
), t AS (
  SELECT
    symbol,
    ts_utc,
    price,
    size,
    LAG(price) OVER (
      PARTITION BY symbol
      ORDER BY ts_utc, price, size
    ) AS prev_price
  FROM trades
), t_signed AS (
  -- Tick rule: sign is +1 if price > prev_price, -1 if price < prev_price,
  -- carry forward last non-zero sign when price == prev_price.
  SELECT
    symbol,
    ts_utc,
    price,
    size,
    CASE
      WHEN prev_price IS NULL THEN NULL
      WHEN price > prev_price THEN 1
      WHEN price < prev_price THEN -1
      ELSE 0
    END AS raw_sign
  FROM t
), t_sign_filled AS (
  SELECT
    symbol,
    ts_utc,
    price,
    size,
    -- Carry forward last non-zero sign using a running max over an encoded sequence.
    -- This is portable SQL: create a group id that increments on non-zero signs.
    SUM(CASE WHEN raw_sign <> 0 THEN 1 ELSE 0 END) OVER (
      PARTITION BY symbol
      ORDER BY ts_utc, price, size
      ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
    ) AS sign_grp,
    raw_sign
  FROM t_signed
), t_final AS (
  SELECT
    symbol,
    ts_utc,
    price,
    size,
    -- Within each sign_grp, the non-zero raw_sign is constant, so MAX works.
    MAX(NULLIF(raw_sign, 0)) OVER (
      PARTITION BY symbol, sign_grp
    ) AS tick_sign
  FROM t_sign_filled
), joined AS (
  SELECT
    t.symbol,
    t.ts_utc AS trade_ts_utc,
    t.price,
    t.size,
    t.tick_sign,
    q.mid,
    ROW_NUMBER() OVER (
      PARTITION BY t.symbol, t.ts_utc, t.price, t.size
      ORDER BY q.ts_utc DESC
    ) AS rn
  FROM t_final t
  JOIN q
    ON q.symbol = t.symbol
   AND q.ts_utc <= t.ts_utc
)
SELECT
  symbol,
  trade_ts_utc,
  price,
  size,
  mid AS quote_mid,
  (price - mid) AS edge_vs_mid,
  COALESCE(tick_sign, 0) * (price * size) AS signed_notional
FROM joined
WHERE rn = 1
ORDER BY symbol, trade_ts_utc;

Citadel's two dedicated coding rounds already thin the herd before you reach the stats and ML gauntlet, which means survivors face back-to-back rounds where interviewers expect you to derive estimators from scratch, then immediately pressure-test whether your result still holds on non-stationary tick data from Citadel's equities or futures desks. The compounding difficulty isn't any single topic; it's that Citadel's EQR interviewers chain questions across stats, ML, and finance intuition within the same round, asking you to, say, justify a cross-validation scheme and then explain how transaction costs on a real Citadel Securities order book would erode the edge your model claims. If your prep plan leans heavily on algorithm drills while treating probability and backtest reasoning as afterthoughts, you're optimizing for the rounds Citadel treats as a floor, not the ones that actually decide offers.

Practice Citadel-tagged questions across all seven areas at datainterview.com/questions.

How to Prepare for Citadel Data Scientist Interviews

Citadel's hedge fund arm generated $5.3 billion in gains recently, with sticky employee compensation eating into those profits, a sign of just how aggressively the firm pays to retain quantitative talent. Data scientists sit inside teams like the Equity Quantitative Research (EQR) group, where the work spans equities microstructure, cross-asset signals, and NLP on filings and news. Everything you build gets pressure-tested against live markets, not parked in a quarterly review deck.

The "why Citadel" answer that actually works ties your specific research interests to something the firm has publicly said. Citadel Securities publishes market structure commentary and year-end outlooks that lay out their views on liquidity dynamics and market internals. Reference one of those pieces, connect it to a signal idea you'd want to explore, and you'll separate yourself from candidates who stop at "I admire the returns."

Try a Real Interview Question

from typing import List
import math


def ewm_zscore(prices: List[float], lam: float) -> List[float]:
    """Compute an online exponentially weighted z-score series from prices.

    Args:
        prices: Time-ordered prices p_0..p_{n-1}. Must be positive.
        lam: Decay parameter lambda with 0 < lam < 1.

    Returns:
        List of z-scores [z_1..z_{n-1}] computed from log returns.
    """
    pass

from typing import List
import math


def ewm_zscore(prices: List[float], lam: float) -> List[float]:
    """Compute an online exponentially weighted z-score series from prices.

    Args:
        prices: Time-ordered prices p_0..p_{n-1}. Must be positive.
        lam: Decay parameter lambda with 0 < lam < 1.

    Returns:
        List of z-scores [z_1..z_{n-1}] computed from log returns.

    Raises:
        ValueError: If inputs are invalid.
    """
    if not (0.0 < lam < 1.0):
        raise ValueError("lam must be in (0, 1)")
    if prices is None or len(prices) < 2:
        return []
    if any((p is None) or (p <= 0.0) for p in prices):
        raise ValueError("all prices must be positive")

    mu = 0.0
    var = 0.0
    out: List[float] = []

    for t in range(1, len(prices)):
        r = math.log(prices[t] / prices[t - 1])
        mu = lam * mu + (1.0 - lam) * r
        diff = r - mu
        var = lam * var + (1.0 - lam) * (diff * diff)
        sigma = math.sqrt(var)
        out.append(0.0 if sigma == 0.0 else diff / sigma)

    return out

Citadel's coding rounds reward clean, efficient solutions to problems that feel like compressed research tasks, not abstract graph puzzles. Focus your practice on time-series manipulation, rolling computations, and edge-case handling around irregular timestamps. Build that muscle at datainterview.com/coding.

Test Your Readiness

Timed reps across Citadel-tagged questions are the fastest way to build comfort with adversarial follow-ups. Start at datainterview.com/questions.