Susquehanna International Group Quantitative Researcher Interview Guide

SIG lists "demonstrated interest in strategic games and/or competitive activities" as a required skill for quant researchers, right alongside Python and probability theory. That tells you everything about how this firm thinks about hiring. Your poker hands matter.

Susquehanna International Group Quantitative Researcher Role

Your job is to find, validate, and ship signals that make SIG's options and equities market-making desks more profitable. You'll write Python (and sometimes C++) against tick-level historical data on SIG's large research clusters, building features, running backtests, and defending every assumption in front of traders who will challenge your methodology. Success means moving a signal from notebook prototype to production where it contributes real PnL, not just publishing a promising Sharpe ratio internally.

A Typical Week

Most of your week isn't coding. The split between explaining your work (in PnL attribution meetings, 1:1s with senior researchers, and Thursday signal presentations) and actually building it is closer to even than candidates expect. SIG's culture of rigorous pushback means you rehearse your reasoning constantly, which is why the game theory mindset matters even on a random Tuesday afternoon when a colleague challenges your out-of-sample testing framework.

Projects & Impact Areas

Core options and equities market-making signal research is where most quant researchers spend the majority of their time, improving volatility surface models and extracting features from order flow microstructure data. SIG also has an active prediction markets specialization (they're hiring quant researchers specifically for it), which poses a fundamentally different challenge: pricing event contracts where historical analogs are thin or nonexistent. Crypto market-making and portfolio construction round out the research surface, with quant researchers contributing frameworks for digital asset liquidity dynamics that behave nothing like traditional equities.

Skills & What's Expected

Expert-level ML and expert-level probability/statistics are both required here, not one at the expense of the other. What's genuinely underrated is business acumen: SIG rates it "high" because you need to reason about transaction costs, adverse selection, and slippage before your signal ever touches production. Comfort with data engineering basics (debugging corrupted data partitions, managing backtest infrastructure on research clusters) won't be your primary focus, but ignoring it will slow you down on mornings when a cluster job fails at 3 AM and you're the one who has to fix the data pull script.

Levels & Career Growth

SIG's flat structure means PnL impact drives promotion, not tenure or headcount management. PhD new grads and experienced hires both get real ownership quickly, but the blocker most researchers hit when trying to move up isn't technical ability. It's the inability to convince traders that a signal is genuinely robust rather than a backtest artifact.

Work Culture

SIG operates in-office at the Bala Cynwyd campus outside Philadelphia, with the culture emphasizing real-time collaboration between quants and traders sitting on the same desk. Hours run roughly 7 AM to 5 or 6 PM, anchored to market hours. Challenging someone's idea directly is expected (and reciprocated), reviews highlight genuine meritocracy and strong benefits, and the game theory training that comes with the job actually sharpens how you think about risk.

Susquehanna International Group Quantitative Researcher Compensation

SIG's comp structure is cash-heavy: a competitive base salary plus a performance bonus that, according to the firm's own framing, depends on both individual and firm-wide results. The bonus component makes up a substantial share of total comp, so expect meaningful year-to-year variance. There may also be long-term incentives in the mix, though details on those aren't publicly standardized, so ask your recruiter directly.

Base salary has some room for negotiation, which is worth knowing because many candidates assume it's fixed and skip straight to discussing bonus. The bonus structure, by contrast, is where SIG is less flexible. Your single biggest lever is demonstrating unique skills that map to SIG's specific needs (pricing novel event contracts for the Robinhood prediction markets joint venture, or crypto market-making experience) rather than relying on generic market-rate arguments.

Susquehanna International Group Quantitative Researcher Interview Process

The process runs about six weeks end-to-end, from what candidates report. The most common reason people wash out isn't weak math. It's poor communication across all technical rounds. SIG's rejection patterns show that candidates who can't articulate assumptions, narrate logical steps, or connect their reasoning to practical trading contexts get cut even when their answers are directionally correct.

The final onsite is a full-day affair mixing quantitative problems with behavioral discussions, and the behavioral component carries real weight. SIG's culture grew out of poker and game theory, so expect the onsite panel to care deeply about how you think through ambiguous decisions, not just how you solve textbook probability. Candidates who coast through behavioral portions while grinding only on stats prep tend to underestimate how much those conversations factor into the final hiring decision.

Susquehanna International Group Quantitative Researcher Interview Questions

from __future__ import annotations

import numpy as np
import pandas as pd


def one_second_midprice_log_returns(quotes: pd.DataFrame) -> pd.Series:
    """Compute 1-second midprice log returns from messy tick quotes.

    Parameters
    ----------
    quotes : pd.DataFrame
        Columns: ts_ns (int nanoseconds since epoch), bid, ask.
        Extra columns are ignored. Rows may be out of order.

    Returns
    -------
    pd.Series
        Indexed by 1-second timestamps (UTC), values are log returns.
        Seconds where bid or ask is missing are dropped.
    """
    required = {"ts_ns", "bid", "ask"}
    missing = required.difference(quotes.columns)
    if missing:
        raise ValueError(f"Missing required columns: {sorted(missing)}")

    df = quotes[["ts_ns", "bid", "ask"]].copy()

    # Parse timestamps and sort to make "last quote in the second" meaningful.
    df["ts"] = pd.to_datetime(df["ts_ns"], unit="ns", utc=True)
    df = df.sort_values("ts", kind="mergesort")  # stable sort

    # Floor to 1-second buckets.
    df["sec"] = df["ts"].dt.floor("s")

    # Take the last observed bid and ask within each second.
    per_sec = df.groupby("sec", sort=True).agg({"bid": "last", "ask": "last"})

    # Drop seconds with missing side.
    per_sec = per_sec.dropna(subset=["bid", "ask"])

    # Midprice, guard against nonpositive values.
    mid = (per_sec["bid"] + per_sec["ask"]) / 2.0
    mid = mid.where(mid > 0)

    # Compute log returns; drop the first NaN.
    r = np.log(mid).diff()
    r = r.dropna()
    r.name = "mid_log_return_1s"
    return r


if __name__ == "__main__":
    # Minimal sanity check with messy ordering and gaps.
    q = pd.DataFrame(
        {
            "ts_ns": [
                2_000_000_100,  # 2.0000001s
                1_500_000_000,  # 1.5s
                2_900_000_000,  # 2.9s
                3_100_000_000,  # 3.1s
            ],
            "bid": [0.48, 0.47, 0.49, 0.50],
            "ask": [0.52, 0.53, 0.51, 0.54],
        }
    )
    out = one_second_midprice_log_returns(q)
    print(out)

from __future__ import annotations

import math
from collections import deque
from typing import Iterable, List, Optional

import numpy as np


def rolling_zscore_no_leakage(
    x: Iterable[float],
    window: int,
    eps: float = 1e-8,
) -> np.ndarray:
    """Rolling z-score with strict no-leakage alignment.

    For each time t, compute z_t = (x_t - mu_t) / sigma_t where mu_t and
    sigma_t are computed from the *previous* `window` observations only.

    Complexity is O(n). Returns NaN until there are `window` prior values.

    Parameters
    ----------
    x : Iterable[float]
        Input series.
    window : int
        Lookback window size W.
    eps : float
        Floor for standard deviation to avoid division by ~0.

    Returns
    -------
    np.ndarray
        z-scores aligned to x.
    """
    if window <= 0:
        raise ValueError("window must be positive")

    x_list = list(x)
    n = len(x_list)
    out = np.full(n, np.nan, dtype=float)

    # Maintain rolling sum and sumsq for previous W values.
    # This is stable enough for typical quant features; eps handles collapse.
    q: deque[float] = deque()
    s = 0.0
    ss = 0.0

    for t in range(n):
        # At time t, compute stats from previous window values only.
        if len(q) == window:
            mu = s / window
            # Var = E[x^2] - (E[x])^2
            ex2 = ss / window
            var = ex2 - mu * mu
            # Numerical guard: var can go slightly negative.
            if var < 0.0:
                var = 0.0
            sigma = math.sqrt(max(var, eps * eps))
            out[t] = (x_list[t] - mu) / sigma

        # Now update window to include x_t for future times.
        xt = float(x_list[t])
        q.append(xt)
        s += xt
        ss += xt * xt

        if len(q) > window:
            old = q.popleft()
            s -= old
            ss -= old * old

    return out


if __name__ == "__main__":
    x = [1, 1, 1, 1, 2, 3, 4, 4]
    z = rolling_zscore_no_leakage(x, window=3, eps=1e-6)
    print(z)

SIG's prediction markets push shows up directly in how they weight questions: the Prediction Markets & Market Microstructure slice is small on its own, but interviewers routinely embed prediction market setups (Kalshi-style binary contracts, event probability pricing) into probability and statistics problems, so the topic bleeds across categories in ways the chart can't capture. That compounding effect means you'll derive a posterior update on an event contract's true probability, then immediately get pressed on whether your backtest of that signal would survive a multiple comparisons critique. The single biggest prep mistake is treating the six areas as independent buckets when SIG's poker-rooted culture rewards candidates who fluidly connect probabilistic reasoning to honest self-assessment of statistical evidence, exactly the way a market maker must think before sizing a bet on a novel event contract.

Drill SIG-relevant probability chains and prediction market pricing problems at datainterview.com/questions.

How to Prepare for Susquehanna International Group Quantitative Researcher Interviews

SIG's near-term priorities center on a joint venture with Robinhood to launch a CFTC-licensed prediction markets exchange and clearinghouse, with SIG committed to providing day-one liquidity. For quant researchers, this likely means working on pricing and risk models for event contracts where historical data is sparse and the contract structures themselves are still evolving. SIG is also actively investing in digital assets, which suggests crypto market-making and portfolio construction are live research areas alongside traditional equities and options.

The "why SIG?" answer that actually lands ties directly to the firm's poker-player origins. SIG's founding story isn't decoration; the firm still runs game theory and poker training because they believe every research decision, from signal selection to position sizing, is an expected value problem with incomplete information. Don't just say you admire the culture. Describe a specific moment where you quantified uncertainty others were hand-waving, or where you updated a belief mid-project because new data shifted the posterior. That's the language SIG's interviewers recognize as native, not borrowed.

Try a Real Interview Question

from typing import Iterable, Tuple


def score_forecasts(ps: Iterable[float], ys: Iterable[int], eps: float = 1e-15) -> Tuple[float, float]:
    """Compute mean negative log loss and mean Brier score for binary forecasts.

    Args:
        ps: Iterable of predicted probabilities.
        ys: Iterable of realized outcomes, each 0 or 1.
        eps: Clipping parameter for probabilities.

    Returns:
        (mean_logloss, mean_brier)
    """
    pass

from typing import Iterable, Tuple
import math


def score_forecasts(ps: Iterable[float], ys: Iterable[int], eps: float = 1e-15) -> Tuple[float, float]:
    """Compute mean negative log loss and mean Brier score for binary forecasts.

    Args:
        ps: Iterable of predicted probabilities.
        ys: Iterable of realized outcomes, each 0 or 1.
        eps: Clipping parameter for probabilities.

    Returns:
        (mean_logloss, mean_brier)

    Raises:
        ValueError: If inputs have different lengths, are empty, eps is invalid,
            or ys contains values other than 0 or 1.
    """
    if not (0.0 < eps < 0.5):
        raise ValueError("eps must satisfy 0 < eps < 0.5")

    it_p = iter(ps)
    it_y = iter(ys)

    n = 0
    sum_logloss = 0.0
    sum_brier = 0.0

    while True:
        try:
            p = next(it_p)
        except StopIteration:
            try:
                next(it_y)
                raise ValueError("ps and ys must have the same length")
            except StopIteration:
                break

        try:
            y = next(it_y)
        except StopIteration:
            raise ValueError("ps and ys must have the same length")

        if y not in (0, 1):
            raise ValueError("ys must contain only 0 or 1")

        if not math.isfinite(p):
            raise ValueError("ps must contain finite floats")

        p = min(1.0 - eps, max(eps, float(p)))

        sum_logloss += -(y * math.log(p) + (1 - y) * math.log(1.0 - p))
        diff = p - y
        sum_brier += diff * diff
        n += 1

    if n == 0:
        raise ValueError("inputs must be non-empty")

    return (sum_logloss / n, sum_brier / n)

SIG's Quantitative Researcher job postings explicitly require Python fluency and production-grade modeling code, so expect coding problems that ask you to simulate, manipulate data, or implement a probabilistic model rather than optimize an abstract algorithm. Build that muscle at datainterview.com/coding.

Test Your Readiness

Sharpen your pattern recognition on probability and statistics problems calibrated to quant finance interviews at datainterview.com/questions.