Goldman Sachs Quantitative Researcher Interview Guide

Candidates constantly confuse Goldman's Quant Researcher and Strats roles, and the prep couldn't be more different. Quant Researchers inside GSAM spend their days building alpha signals and risk models that feed directly into portfolio decisions. Strats, by contrast, own the production systems those models run on. If you're not sure which one you're targeting, figure that out before you spend a single hour studying.

Goldman Sachs Quantitative Researcher Role

Success in year one looks like a signal you researched making it into the team's live systematic equity or multi-asset book, with your name on the PnL attribution. That's what separates this from a generic research scientist seat: your work doesn't sit in a paper or a dashboard. It moves capital through GSAM's Quantitative Investment Strategies pod, and the portfolio manager will notice if it decays.

A Typical Week

What the breakdown won't fully convey is how much context-switching happens before most people's commute starts. Pre-market signal checks bleed into standup discussions about drawdowns, and by mid-morning you're debugging a data ingestion issue in an Airflow DAG, not doing research. The writing allocation looks small on paper, but Goldman's culture treats an undocumented signal as a signal that doesn't exist, so those research memos carry outsized career weight relative to the hours they consume.

Projects & Impact Areas

Alpha signal research anchors the role, where you might spend weeks prototyping a new feature selector in PyTorch and benchmarking it against the team's existing XGBoost ensemble on out-of-sample Sharpe. That research naturally pulls you into risk model work: stress-testing how your signal behaves across regimes using walk-forward optimizations that check turnover, sector concentration, and drawdown. Alternative data integration (satellite imagery, NLP-derived sentiment) is an active area on some desks, though it's still more exploratory than production-grade.

Skills & What's Expected

Underrated: the ability to explain a signal's capacity estimate to a PM managing a multi-billion dollar book. The skill scores show expert-level math/statistics and expert-level business acumen rated equally, which is unusual for a quant role and tells you exactly what Goldman optimizes for. Strong ML knowledge matters (it's scored high, and the job descriptions call it out explicitly), but candidates who can derive a formula yet can't articulate why it matters for portfolio construction tend to stall in the interview.

Levels & Career Growth

Most PhD holders enter at Associate, while strong Master's candidates start at Analyst. The promotion that trips people up is Associate to VP, because the bar shifts from "contributed to a production model" to "independently conceived and owns a research agenda." That distinction is real and worth internalizing early, since it shapes how you should scope projects from day one.

Work Culture

Based on candidate reports and Goldman's own public stance, the firm maintains a five-day in-office expectation at 200 West Street, one of the more aggressive return-to-office positions on Wall Street. Hours tend to run long but are more predictable than investment banking, with spikes around quarterly risk reviews or signal promotions to production. Your pod of 8-10 researchers operates more like a small academic department than a corporate team, and the rigor of the written-artifact culture means your work gets real scrutiny.

Goldman Sachs Quantitative Researcher Compensation

Bonus is where Goldman's comp gets interesting and unpredictable. Your annual bonus is discretionary, shaped by both firm-wide revenue and your desk's performance, so it can swing meaningfully year to year. Some quant researchers also receive deferred compensation or RSUs that vest over several years, but the specifics vary by level and team, so press your recruiter for exact vesting terms before you sign.

When negotiating, the source data points to total compensation (not just base) as the right frame, and sign-on bonuses as a real lever worth pushing on. If you're holding a competing offer from a firm like Citadel or Two Sigma, use it to negotiate the overall package rather than fixating on base salary alone, because base tends to have the narrowest band of flexibility at Goldman.

Goldman Sachs Quantitative Researcher Interview Process

The process spans about 8 weeks on paper, but from what candidates report, the gap between the initial video screen and the Super Day is where time quietly disappears. Poor communication of technical ideas, not wrong answers, is the rejection pattern that shows up most often in candidate debriefs. Interviewers at GSAM want to hear you connect a derivation to something concrete, like why your choice of volatility model matters for a specific portfolio's risk budget. Getting the math right while treating it as an abstract exercise won't clear the bar.

Don't sleepwalk into the behavioral round. The interviewer is often a senior team member or hiring manager who's evaluating whether you can talk about GSAM's actual business, not just recite Goldman's principles page. Reference something specific: the firm's push into model portfolios with partners like T. Rowe Price, or how alternatives demand is reshaping the strategies your team would support. Generic prestige answers are a fast path to rejection.

Goldman Sachs Quantitative Researcher Interview Questions

from __future__ import annotations

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


def realized_vol_5min(
    ticks: List[Tuple[int, float]],
    window_seconds: int = 300,
    annualization_factor: float = None,
) -> List[Tuple[int, Optional[float]]]:
    """Compute 5-minute realized volatility at each tick.

    ticks: list of (timestamp_seconds, mid), sorted ascending by timestamp.
    RV uses log returns between consecutive ticks that both lie in the last `window_seconds`.

    Returns list of (timestamp_seconds, rv) where rv is None until >= 2 prices in window.
    """

    if annualization_factor is None:
        # 252 trading days, 6.5 hours/day, 60 minutes/hour.
        annualization_factor = math.sqrt(252.0 * 6.5 * 60.0)

    n = len(ticks)
    out: List[Tuple[int, Optional[float]]] = []
    if n == 0:
        return out

    # Keep a deque of (t_i, r_i) where r_i is log return from tick i-1 to i.
    # Also keep rolling sum of squares of returns.
    returns: Deque[Tuple[int, float]] = deque()
    sum_sq = 0.0

    prev_t: Optional[int] = None
    prev_p: Optional[float] = None

    for t, p in ticks:
        # Validate inputs conservatively.
        if prev_t is not None and t < prev_t:
            raise ValueError("ticks must be sorted by timestamp")
        if p <= 0.0:
            # Log return undefined. In production you might drop or carry forward.
            # Here, treat as breaking the chain.
            prev_t, prev_p = t, None
            # Also flush returns because continuity is broken.
            returns.clear()
            sum_sq = 0.0
            out.append((t, None))
            continue

        if prev_p is not None:
            r = math.log(p / prev_p)
            returns.append((t, r))
            sum_sq += r * r

        # Evict returns whose endpoint timestamp is older than window start.
        window_start = t - window_seconds
        while returns and returns[0][0] <= window_start:
            old_t, old_r = returns.popleft()
            sum_sq -= old_r * old_r

        # You have k returns in window, which implies k+1 prices, but continuity can break.
        k = len(returns)
        if k >= 1:
            # Realized variance is sum of squared log returns.
            rv = math.sqrt(max(sum_sq, 0.0)) * annualization_factor
            out.append((t, rv))
        else:
            out.append((t, None))

        prev_t, prev_p = t, p

    return out


if __name__ == "__main__":
    # Minimal sanity check.
    data = [
        (0, 100.0),
        (10, 100.1),
        (20, 99.9),
        (400, 101.0),  # window resets effectively
        (410, 101.2),
    ]
    res = realized_vol_5min(data)
    for row in res:
        print(row)

The compounding difficulty here is that Goldman's probability questions bleed directly into its financial modeling questions. A Poisson jump-size problem isn't just a brainteaser; it's a setup for pricing exotic options under compound processes, which is exactly the kind of bridge GSAM desks need quant researchers to cross daily. Candidates who prep these areas in isolation, drilling probability flashcards separately from derivatives theory, miss the connective tissue Goldman is actually testing for.

Drill Goldman-style questions that span these overlapping areas at datainterview.com/questions.

How to Prepare for Goldman Sachs Quantitative Researcher Interviews

Goldman Sachs Asset Management oversees approximately $3.5 trillion in assets under supervision, and the firm posted revenue of roughly $59.4 billion with 15.2% year-over-year growth. That growth is concentrated in areas where Quant Researchers sit: GSAM's 2026 investment outlook highlights expanding opportunities in alternatives and multi-asset solutions, while a separate forecast from the firm projects that demand for alternatives will outstrip origination supply. Meanwhile, the new co-branded model portfolio partnership with T. Rowe Price makes systematic portfolio construction the actual product being sold to advisors.

The "why Goldman" answer that works ties your research skills to one of these specific bets. Something like: "GSAM is scaling model portfolios for the advisor channel while pushing deeper into alternatives. I want to build the factor models and risk decompositions that make those portfolios defensible at scale." Generic talk about prestige or "smart colleagues" won't register because it doesn't show you understand which desk's P&L your work would touch.

Try a Real Interview Question

from typing import List, Tuple


def ewma_vol_and_var(returns: List[float], lam: float, alpha: float, notional: float) -> Tuple[float, float]:
    """Compute EWMA volatility and 1-day Gaussian VaR.

    Args:
        returns: Daily log returns r_1..r_n.
        lam: EWMA decay parameter in (0, 1).
        alpha: Tail probability in (0, 1), e.g. 0.01 for 99% VaR.
        notional: Portfolio notional.

    Returns:
        (sigma_n, VaR) where sigma_n is the latest EWMA volatility and VaR is positive.
    """
    pass

from typing import List, Tuple
import math


def _inv_norm_cdf(p: float) -> float:
    """Approximate inverse standard normal CDF (Acklam's approximation).

    Accurate to ~1e-9 in the central region and adequate for risk applications.
    """
    if not (0.0 < p < 1.0):
        raise ValueError("p must be in (0, 1)")

    a = [
        -3.969683028665376e01,
        2.209460984245205e02,
        -2.759285104469687e02,
        1.383577518672690e02,
        -3.066479806614716e01,
        2.506628277459239e00,
    ]
    b = [
        -5.447609879822406e01,
        1.615858368580409e02,
        -1.556989798598866e02,
        6.680131188771972e01,
        -1.328068155288572e01,
    ]
    c = [
        -7.784894002430293e-03,
        -3.223964580411365e-01,
        -2.400758277161838e00,
        -2.549732539343734e00,
        4.374664141464968e00,
        2.938163982698783e00,
    ]
    d = [
        7.784695709041462e-03,
        3.224671290700398e-01,
        2.445134137142996e00,
        3.754408661907416e00,
    ]

    plow = 0.02425
    phigh = 1.0 - plow

    if p < plow:
        q = math.sqrt(-2.0 * math.log(p))
        num = (((((c[0] * q + c[1]) * q + c[2]) * q + c[3]) * q + c[4]) * q + c[5])
        den = ((((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1.0)
        return num / den

    if p > phigh:
        q = math.sqrt(-2.0 * math.log(1.0 - p))
        num = (((((c[0] * q + c[1]) * q + c[2]) * q + c[3]) * q + c[4]) * q + c[5])
        den = ((((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1.0)
        return -(num / den)

    q = p - 0.5
    r = q * q
    num = (((((a[0] * r + a[1]) * r + a[2]) * r + a[3]) * r + a[4]) * r + a[5]) * q
    den = (((((b[0] * r + b[1]) * r + b[2]) * r + b[3]) * r + b[4]) * r + 1.0)
    return num / den


def ewma_vol_and_var(returns: List[float], lam: float, alpha: float, notional: float) -> Tuple[float, float]:
    """Compute EWMA volatility and 1-day Gaussian VaR.

    Args:
        returns: Daily log returns r_1..r_n.
        lam: EWMA decay parameter in (0, 1).
        alpha: Tail probability in (0, 1), e.g. 0.01 for 99% VaR.
        notional: Portfolio notional.

    Returns:
        (sigma_n, VaR) where sigma_n is the latest EWMA volatility and VaR is positive.
    """
    if not (0.0 < lam < 1.0):
        raise ValueError("lam must be in (0, 1)")
    if not (0.0 < alpha < 1.0):
        raise ValueError("alpha must be in (0, 1)")
    if notional < 0.0:
        raise ValueError("notional must be non-negative")
    if not returns:
        raise ValueError("returns must be non-empty")

    n = len(returns)
    m = 20 if n >= 20 else n

    window = returns[:m]
    mean = sum(window) / m
    if m == 1:
        s2 = 0.0
    else:
        s2 = sum((x - mean) ** 2 for x in window) / (m - 1)

    var = s2
    for r in returns:
        var = lam * var + (1.0 - lam) * (r * r)

    sigma = math.sqrt(var)
    z = _inv_norm_cdf(1.0 - alpha)
    var_amount = max(0.0, z * sigma * notional)
    return sigma, var_amount

From what candidates report, Goldman's coding round skews toward Python implementation of numerical and statistical methods rather than abstract data structure puzzles. Practice problems involving simulation, optimization, and time series manipulation at datainterview.com/coding to build that muscle.

Test Your Readiness

The quiz above flags where your gaps are. Drill your weakest categories at datainterview.com/questions, paying extra attention to probability and inference since those topics span multiple rounds.