Optiver Quantitative Researcher Interview Guide

Optiver's Monday morning PnL review isn't a status update you passively attend. It's a room where traders interrogate your pricing model's performance from the prior week, and your ability to explain why implied correlation spiked on Thursday afternoon matters more than whether your backtest looked clean in a notebook.

Optiver Quantitative Researcher Role

You'll build the mathematical models behind Optiver's market-making operation across options, futures, and ETFs, spanning equities, fixed income, and commodities globally. Success after year one looks like a fair-value pricing model or alpha signal you developed running in production, with traders on your paired desk referencing it during daily decisions and your contribution visible in PnL decomposition. Your research code ships in Python and C++, gets tested by live markets, and feeds directly into the weekly strategy reviews where the trading desk dissects what worked and what didn't.

A Typical Week

Most of your week isn't coding. Research, analysis, and meetings with traders and risk managers consume the majority of your hours, which reflects the actual hard problem: figuring out which volatility surface model to build and then defending your assumptions to a skeptical trading desk during Thursday's reading group, where the culture rewards intellectual honesty over polished presentations.

Projects & Impact Areas

Optiver organizes QR work around pricing, risk, and execution, but in practice these bleed together. You might build an online estimation model for basket implied correlation on ETF options, then realize those same estimates improve the desk's real-time Greeks hedging, which pulls you into conversations with trading systems engineers about data ingestion latency. Optiver's investment in Brazil's A5X derivatives exchange also opens projects where QRs adapt existing model families to market structures with sparse historical data and unfamiliar microstructure rules.

Skills & What's Expected

C++ fluency is the most underrated differentiator for this role. Every serious applicant has strong math and Python, but Optiver's latency-sensitive trading infrastructure means researchers who can take a promising Python prototype and rewrite it in production-quality C++ (like converting a research-stage correlation estimator into something deployable) get their work live faster and earn outsized influence. GenAI and LLM skills carry little weight here, though ML broadly is important: time-series forecasting, signal extraction, and feature engineering for trading data are daily tools, not interview trivia.

Levels & Career Growth

Graduate QR is the standard entry point for PhDs, with some BS/MS hires joining in roles that emphasize computational research. The jump to Senior QR is where careers stall, and the blocker is rarely technical skill. It's demonstrating that your research contributed to real trading outcomes, not just that it passed a backtest or produced an elegant internal paper.

Work Culture

The Amsterdam HQ is fully in-office, open trading floor, with QRs sitting directly next to traders and engineers. Days start around 7:15-7:30 AM and wind down by 5-6 PM, with genuine encouragement to disconnect after hours. That physical proximity is both the best and hardest part: you'll get pulled into real-time trading discussions and Friday afternoon knowledge-sharing sessions, which is energizing if you thrive on tight feedback loops but disruptive if you need long stretches of uninterrupted deep work.

Optiver Quantitative Researcher Compensation

Equity and RSUs are, from what candidates report, generally not part of Optiver's offer. That makes your annual performance bonus the dominant variable in total comp, tied to both your individual PnL contribution and broader firm performance. Understanding how Optiver's bonus structure has historically paid out matters more than negotiating an extra few thousand in base, so ask pointed questions about bonus ranges during the process rather than fixating on the base number alone.

When negotiating, the source data is clear: articulate your value through skills and competing offers. Base salary has some flexibility, but the bonus component is where Optiver's real compensation lives, and that's largely formula-driven by performance. Focus your negotiation energy on total compensation as a single figure rather than trying to move individual line items in isolation.

Optiver Quantitative Researcher Interview Process

The full loop runs about six weeks, which is faster than most hedge funds but not blazing by prop shop standards. The top rejection reason is speed on probability and mental math, not getting problems wrong but solving them too slowly. Optiver's dedicated online assessment and live stats interview both filter for reflexive quantitative reasoning before you reach any coding or modeling discussion, so candidates who've spent years in ML research but haven't touched conditional expectation problems since grad school often exit the process before their strongest rounds even begin.

Optiver's behavioral round sits last, and it's not a cooldown lap. The firm's QR role requires you to present findings to traders and defend assumptions under direct pushback, so that final interview specifically probes whether you can hold a position, absorb criticism, and adjust without getting defensive or evasive. From what candidates report, strong technical performers still receive rejections when they treat this round as a checkbox.

Optiver Quantitative Researcher Interview Questions

from collections import deque
from typing import List, Tuple


def streaming_twam_1000ms(ticks: List[Tuple[int, float]], window_ms: int = 1000) -> List[float]:
    """Compute time-weighted average mid over the trailing window_ms at each tick.

    ticks: list of (timestamp_ms, mid), timestamps nondecreasing integers.
    Returns: TWAM after each tick, using only information up to that tick.

    Definition: mid is piecewise-constant between ticks.
    For the current tick at time t_k, window is [t_k - window_ms, t_k].
    If there is no elapsed time yet, TWAM is defined as current mid.
    """
    if not ticks:
        return []

    # Each deque element is a segment (start, end, value), end > start.
    segments = deque()

    # Rolling area and duration over the current window.
    area = 0.0
    duration = 0.0

    out = []

    prev_t, prev_mid = ticks[0]
    # At the first tick, there is no time interval, define TWAM as current mid.
    out.append(prev_mid)

    for t, mid in ticks[1:]:
        if t < prev_t:
            raise ValueError("Timestamps must be nondecreasing")

        # Add the segment from prev_t to t with value prev_mid.
        if t > prev_t:
            seg_start, seg_end, seg_val = prev_t, t, prev_mid
            seg_len = seg_end - seg_start
            segments.append([seg_start, seg_end, seg_val])
            area += seg_len * seg_val
            duration += seg_len

        # Evict or trim segments that fall before window start.
        window_start = t - window_ms
        while segments and segments[0][1] <= window_start:
            s, e, v = segments.popleft()
            seg_len = e - s
            area -= seg_len * v
            duration -= seg_len

        # If the earliest segment partially overlaps the window, trim its left part.
        if segments and segments[0][0] < window_start < segments[0][1]:
            s, e, v = segments[0]
            trim_len = window_start - s
            area -= trim_len * v
            duration -= trim_len
            segments[0][0] = window_start

        # Now compute TWAM over [t-window_ms, t].
        # Note: the interval (t, next_t] is not known yet, so only accumulated duration counts.
        if duration > 0:
            out.append(area / duration)
        else:
            # No elapsed time in window, fall back to current mid.
            out.append(mid)

        prev_t, prev_mid = t, mid

    return out


if __name__ == "__main__":
    # Simple sanity check
    ticks = [(0, 10.0), (200, 12.0), (700, 11.0), (1200, 13.0)]
    print(streaming_twam_1000ms(ticks))

from collections import deque
from typing import List, Tuple


def max_mid_drawdown_1s(events: List[Tuple[int, float, float]], window_us: int = 1_000_000) -> float:
    """Maximum (max mid - min mid) within any trailing window_us window.

    events: list of (timestamp_us, bid, ask), timestamps nondecreasing.
    window: [t - window_us, t] for each event time t.
    Returns the maximum drawdown value over all windows.
    """
    if not events:
        return 0.0

    # Store pairs (t, mid) in two deques with monotonic mid values.
    maxdq = deque()  # decreasing mids
    mindq = deque()  # increasing mids

    best = 0.0

    for t, bid, ask in events:
        mid = (bid + ask) / 2.0
        if maxdq and t < maxdq[-1][0]:
            raise ValueError("Timestamps must be nondecreasing")

        # Push into maxdq, maintain decreasing mid.
        while maxdq and maxdq[-1][1] <= mid:
            maxdq.pop()
        maxdq.append((t, mid))

        # Push into mindq, maintain increasing mid.
        while mindq and mindq[-1][1] >= mid:
            mindq.pop()
        mindq.append((t, mid))

        # Evict out-of-window elements from the front.
        start = t - window_us
        while maxdq and maxdq[0][0] < start:
            maxdq.popleft()
        while mindq and mindq[0][0] < start:
            mindq.popleft()

        # Current window drawdown.
        if maxdq and mindq:
            best = max(best, maxdq[0][1] - mindq[0][1])

    return best


if __name__ == "__main__":
    events = [
        (0, 99.0, 101.0),
        (200_000, 100.0, 102.0),
        (600_000, 98.0, 100.0),
        (1_100_000, 101.0, 103.0),
    ]
    print(max_mid_drawdown_1s(events))

Optiver's question mix reveals a firm that treats probability and statistics as load-bearing walls, not decoration. The compounding difficulty shows up when these two areas intersect with market microstructure: sample questions ask you to reason about Poisson-driven mid-price moves and microstructure noise in volatility estimation simultaneously, so weakness in either foundational area cascades into topics like ML feature engineering and inventory management for Optiver's options books. If you're coming from a pure ML background, the distribution is a blunt warning: your time-series modeling chops won't get a real workout until you've survived questions that demand fluent stochastic reasoning applied to Optiver-specific contexts like delta hedging markouts and OPRA quote timestamps.

Practice with questions calibrated to this distribution at datainterview.com/questions.

How to Prepare for Optiver Quantitative Researcher Interviews

Optiver reported strong financial results for 2024, pulling in €3.8B in revenue (up 26% year-over-year). That momentum is showing up in concrete moves: a new NYC office positioned to compete directly with Citadel Securities and Jane Street, and a strategic investment in Brazil's A5X derivatives exchange aimed at bringing additional capacity to Brazil's capital markets. For a QR candidate, these moves matter because they signal where new research problems will come from.

Most "why Optiver" answers fall flat because they could describe any market maker. What separates you: referencing Optiver's three pillars (pricing, risk, and execution) and explaining which pillar your past work maps onto. Someone who's modeled order book dynamics can speak directly to the execution pillar's latency constraints, while a candidate with estimation theory research can connect it to Optiver's pricing challenges across thousands of instruments simultaneously.

Try a Real Interview Question

from typing import Iterable, List, Sequence, Tuple


def microprice(book: Sequence[Tuple[float, float, float, float]]) -> List[float]:
    """Compute microprice for each (bid_price, ask_price, bid_size, ask_size) snapshot.

    Args:
        book: Sequence of tuples (b, a, qb, qa).

    Returns:
        List of microprices, one per snapshot.
    """
    pass

from typing import List, Sequence, Tuple


def microprice(book: Sequence[Tuple[float, float, float, float]]) -> List[float]:
    """Compute microprice for each (bid_price, ask_price, bid_size, ask_size) snapshot.

    Args:
        book: Sequence of tuples (b, a, qb, qa).

    Returns:
        List of microprices, one per snapshot.
    """
    out: List[float] = []
    for b, a, qb, qa in book:
        denom = qb + qa
        if denom == 0:
            out.append(0.5 * (a + b))
        else:
            out.append((a * qb + b * qa) / denom)
    return out

Optiver's Coding & Algorithms round leans toward research implementation (rolling computations, simulation design, numerical methods) rather than abstract data structure puzzles. The emphasis on clean, testable code reflects how QRs here write production research code in Python and C++, not throwaway notebooks. Build that muscle at datainterview.com/coding.

Test Your Readiness

Optiver's two consecutive Statistics & Probability rounds mean your conditional expectation and Bayesian reasoning need to be automatic, not reconstructed on the fly. Get reps at datainterview.com/questions.