JP Morgan Chase Quantitative Researcher Interview Guide

From hundreds of mock interviews we've run, one pattern keeps showing up with JP Morgan quant research candidates: they drill probability puzzles and stochastic calculus for weeks, then freeze when an interviewer asks them to explain how a model's output would change a trader's hedge ratio on the Rates desk. JP Morgan's QR interviews test both, and the communication piece trips up more people than the math.

JP Morgan Chase Quantitative Researcher Role

As a quant researcher at JP Morgan, you build and maintain the mathematical models that price and hedge derivatives across the firm's Rates, Equities, and Wholesale Credit desks, while also contributing to market risk frameworks like VaR and expected shortfall models that feed directly into regulatory capital calculations. The role sits closer to traders than at most banks: you'll field questions about Greeks behavior on live positions and present model updates to risk managers weekly. What separates people who thrive from those who tread water is earning enough trader trust that they seek your input before you offer it, something that looks different on every desk but always requires both technical depth and clear communication.

A Typical Week

The thing that catches most candidates off guard isn't the math intensity. It's the writing. JP Morgan's QR group requires formal internal research notes (with structured templates covering hypothesis, data sources, methodology, and results) before anything moves toward production, and you'll present those findings to PMs and CRO-side risk managers who will push hard on out-of-sample robustness. Expect your Thursday to feel more like defending a dissertation chapter than writing code.

Projects & Impact Areas

Derivatives pricing and hedging is the core: calibrating stochastic volatility surfaces for exotic options on the Rates desk, maintaining pricing models for structured credit instruments in Wholesale Credit, iterating on these models in Python or C++ as market regimes shift. That work feeds into a parallel track on the market risk side, where quant researchers develop stress testing frameworks and validate risk models under regulatory standards like FRTB and SA-CCR, work that directly shapes how much capital the firm's desks can deploy. Some teams also run signal research using statistical methods and alternative data sources, though the center of gravity for most QR roles remains rooted in pricing and risk rather than pure alpha generation.

Skills & What's Expected

What's overrated for getting through the interview is algorithm puzzle speed. What's underrated is your ability to stand in front of a portfolio manager and defend a modeling choice in language that maps to PnL, not measure theory. The skill profile data rates communication and visualization at the same tier as machine learning, both "high," and that matches reality: you write formal research notes, present to traders, and explain risk model behavior to regulators. Strong Python is table stakes, C++ matters on performance-sensitive desks, and KDB shows up on certain trading teams for time-series work. But none of that coding skill helps if you can't articulate why your model's assumptions are appropriate for the product it prices.

Levels & Career Growth

Most external hires with a PhD enter at Associate or VP, depending on whether they bring post-doc or industry experience. The promotion from Associate to VP hinges on independent model ownership: can a trader call you directly about a pricing question without looping in your manager? Lateral moves between desks (Rates to Credit, or QR into model validation) are common and can unstick a career that's plateaued.

Work Culture

JP Morgan's hybrid policy requires at least three days per week in the Manhattan office (383 Madison or 277 Park, depending on your desk), though many desk-aligned quants come in four or five days because proximity to traders matters. The bureaucracy is real: compliance training, model governance gates, and multi-layer code review add overhead you won't find at a small hedge fund. The tradeoff is access to datasets and infrastructure at a scale almost no other employer can match, plus enough institutional stability to run multi-year research programs.

JP Morgan Chase Quantitative Researcher Compensation

The annual bonus is the real comp lever, and it comes with strings. JP Morgan's quant researcher pay includes a significant performance-based bonus on top of base salary, plus potential RSU grants that vest over several years. If you're comparing a JP Morgan offer against a hedge fund, make sure you're accounting for the portion of comp that's locked up in equity you can't touch immediately.

The source data confirms base salary has a narrower band, but it's not immovable. You can push on base with a strong competing offer from a firm like Citadel or Two Sigma. That said, the sign-on bonus and guaranteed first-year bonus tend to be where JP Morgan has the most flexibility, so lead your negotiation there if you want the fastest path to a better total package.

JP Morgan Chase Quantitative Researcher Interview Process

Expect ghosting. The widget shows a tidy three-week timeline, but candidates on QuantNet and Reddit frequently report multi-week silences after the hiring manager screen, especially when the desk is juggling multiple reqs. Don't read silence as rejection; follow up politely at the two-week mark.

A common reason candidates get cut, based on reported rejection patterns, is not wrong answers but a shallow problem-solving approach. JP Morgan's Superday panelists (VPs and senior quants from the desk) probe across math, coding, ML, finance, and behavioral topics in a single four-hour gauntlet. That breadth means a weak showing in even a "minor" area like finance intuition or communication can outweigh strong performance elsewhere, because each interviewer evaluates a different slice and flags concerns independently.

JP Morgan Chase Quantitative Researcher Interview Questions

from __future__ import annotations

import bisect
from dataclasses import dataclass
from typing import List, Optional


@dataclass
class _Tuple:
    """GK summary tuple.

    v: value
    g: minimum rank jump since previous tuple
    delta: maximum additional rank uncertainty
    """

    v: float
    g: int
    delta: int


class GKQuantile:
    """Greenwald-Khanna streaming quantile estimator.

    Guarantees rank error at most epsilon * n.
    Reference: Greenwald and Khanna (2001).

    API:
      - update(x): ingest one observation
      - query(p): approximate p-quantile for p in [0, 1]

    Notes:
      - This is appropriate for streaming VaR-style quantiles on large PnL streams.
      - The error is on rank, not on the value.
    """

    def __init__(self, epsilon: float = 0.01):
        if not (0.0 < epsilon < 1.0):
            raise ValueError("epsilon must be in (0, 1)")
        self.epsilon = float(epsilon)
        self.n = 0
        self.S: List[_Tuple] = []  # sorted by v

    def update(self, x: float) -> None:
        """Insert one value into the GK summary."""
        self.n += 1

        # Find insertion position by value.
        pos = bisect.bisect_left([t.v for t in self.S], x)

        if pos == 0 or pos == len(self.S):
            # At extremes, delta is 0 because rank is exact at min/max.
            new_t = _Tuple(v=x, g=1, delta=0)
        else:
            # Interior insert: delta depends on current allowable error.
            # Use floor(2 * epsilon * n) - 1 per standard GK.
            delta = int((2.0 * self.epsilon * self.n)) - 1
            if delta < 0:
                delta = 0
            new_t = _Tuple(v=x, g=1, delta=delta)

        self.S.insert(pos, new_t)
        self._compress()

    def query(self, p: float) -> Optional[float]:
        """Return approximate p-quantile, or None if empty."""
        if not self.S:
            return None
        if p <= 0.0:
            return self.S[0].v
        if p >= 1.0:
            return self.S[-1].v

        r = int((p * (self.n - 1)) + 1)  # desired rank in 1..n
        max_rank_error = int(self.epsilon * self.n)

        # Walk cumulative minimum rank.
        rmin = 0
        best = self.S[0].v
        for t in self.S:
            rmin += t.g
            rmax = rmin + t.delta
            # GK selection condition: pick smallest v such that r + err <= rmax
            if r + max_rank_error <= rmax:
                return t.v
            best = t.v

        # Fallback, should not happen often.
        return best

    def _compress(self) -> None:
        """Compress adjacent tuples while preserving error guarantees."""
        if len(self.S) < 2:
            return

        # Standard GK compression scans from the end to avoid edge issues.
        # Merge t_i into t_{i+1} if g_i + g_{i+1} + delta_{i+1} <= floor(2*eps*n)
        threshold = int(2.0 * self.epsilon * self.n)

        i = len(self.S) - 2
        while i > 0:  # keep first and last exact
            t = self.S[i]
            t_next = self.S[i + 1]
            if t.g + t_next.g + t_next.delta <= threshold:
                # Merge: keep value of t_next, add g.
                t_next.g += t.g
                # Remove t
                self.S.pop(i)
            i -= 1


# Example usage
if __name__ == "__main__":
    gk = GKQuantile(epsilon=0.01)
    for x in [0.1, -0.2, 0.05, 0.3, 0.25, -0.1, 0.0]:
        gk.update(x)
    print("Approx 5% VaR:", gk.query(0.05))
    print("Approx 50%:", gk.query(0.50))
    print("Approx 99% VaR:", gk.query(0.99))

from __future__ import annotations

import math
from typing import Tuple


def trinomial_european_call_price_delta(
    S0: float,
    K: float,
    r: float,
    q: float,
    sigma: float,
    T: float,
    N: int,
) -> Tuple[float, float]:
    """Recombining trinomial tree pricer for a European call with dividend yield.

    Returns:
      price: option value at t=0
      delta: derivative dV/dS at t=0 estimated from first time step nodes

    Uses a common stable parametrization:
      dt = T/N
      u = exp(sigma * sqrt(2*dt)), d = 1/u
      nu = r - q - 0.5*sigma^2
      pu = 0.5*((sigma^2*dt + (nu*dt)^2)/(sigma^2*dt) + (nu*dt)/(sigma*sqrt(2*dt)))
      pd = 0.5*((sigma^2*dt + (nu*dt)^2)/(sigma^2*dt) - (nu*dt)/(sigma*sqrt(2*dt)))
      pm = 1 - pu - pd

    This gives nonnegative probabilities for reasonable dt.
    """

    if N <= 0:
        raise ValueError("N must be positive")
    if T <= 0:
        raise ValueError("T must be positive")
    if sigma < 0:
        raise ValueError("sigma must be nonnegative")

    dt = T / N
    disc = math.exp(-r * dt)

    if sigma == 0.0:
        # Deterministic forward under risk-neutral drift.
        ST = S0 * math.exp((r - q) * T)
        price = disc ** N * max(ST - K, 0.0)
        # Delta is either 0 or 1 in deterministic case, with kink at ST=K.
        delta = 1.0 if ST > K else 0.0
        return price, delta

    u = math.exp(sigma * math.sqrt(2.0 * dt))
    d = 1.0 / u

    nu = (r - q) - 0.5 * sigma * sigma
    a = nu * dt
    b = sigma * math.sqrt(2.0 * dt)

    # Probabilities.
    pu = 0.5 * (((sigma * sigma * dt + a * a) / (sigma * sigma * dt)) + (a / b))
    pd = 0.5 * (((sigma * sigma * dt + a * a) / (sigma * sigma * dt)) - (a / b))
    pm = 1.0 - pu - pd

    # Clamp tiny negative values from floating error.
    eps = 1e-15
    pu = max(pu, 0.0)
    pm = max(pm, 0.0)
    pd = max(pd, 0.0)
    s = pu + pm + pd
    pu, pm, pd = pu / s, pm / s, pd / s

    # Terminal payoffs. At step N, nodes correspond to net up moves k in [-N, N].
    # Stock at node k is S0 * u^k.
    V = [0.0] * (2 * N + 1)
    for j in range(2 * N + 1):
        k = j - N
        S = S0 * (u ** k)
        V[j] = max(S - K, 0.0)

    # Backward induction.
    for i in range(N - 1, -1, -1):
        V_new = [0.0] * (2 * i + 1)
        for j in range(2 * i + 1):
            # children indices in V at time i+1:
            # up: j+2, mid: j+1, down: j
            V_new[j] = disc * (pu * V[j + 2] + pm * V[j + 1] + pd * V[j])
        V = V_new

        # Save first-step values for Delta after finishing i=0.
        if i == 1:
            # At time 1, there are 3 nodes: k in {-1, 0, +1}
            V_d, V_m, V_u = V[0], V[1], V[2]

    price = V[0]

    # Delta from first-step up and down nodes at t=dt (more stable than bumping S0).
    S_u = S0 * u
    S_d = S0 * d
    delta = (V_u - V_d) / (S_u - S_d)

    return price, delta


if __name__ == "__main__":
    p, dlt = trinomial_european_call_price_delta(
        S0=100.0, K=100.0, r=0.03, q=0.01, sigma=0.2, T=1.0, N=200
    )
    print("Price:", p)
    print("Delta:", dlt)

JP Morgan's quant research interviews chain topics together in ways that punish shallow prep. An interviewer on the Rates desk might open with a Vasicek SDE, ask you to derive the bond pricing PDE on the spot, then pivot into how you'd backtest the resulting VaR model against clustered FOMC exceptions. That seamless jump from stochastic calculus into statistical diagnostics into risk interpretation mirrors the actual workflow on JP Morgan's trading desks, and it's where candidates with siloed preparation fall apart. From what candidates report, no single topic area is safe to deprioritize: a clean Itô derivation won't save you if your Monte Carlo implementation is buggy, and vice versa.

Build that cross-topic fluency with realistic practice at datainterview.com/questions.

How to Prepare for JP Morgan Chase Quantitative Researcher Interviews

JP Morgan Chase posted $168.2 billion in revenue last year while growing its workforce to over 318,000 employees. The 2025 Investor Day presentation highlights continued investment in risk infrastructure and quantitative capabilities across CIB, which tells you the firm sees quant research as a growth area worth funding, not a cost center to trim.

The biggest mistake in your "why JP Morgan" answer is talking about prestige. Interviewers want desk-level specificity. If you're interviewing for Rates, mention that JP Morgan's position as the largest U.S. bank by assets means the derivatives book you'd model against is orders of magnitude larger than what regional banks or boutique shops can offer, creating calibration and hedging problems unique to that scale. For Equities Alpha, talk about cross-asset data access across CIB's trading desks. Tie every sentence to a problem that wouldn't exist somewhere smaller.

Try a Real Interview Question

def mc_delta_call_crn(S0: float, K: float, r: float, sigma: float, T: float, n_paths: int, epsilon: float, seed: int = 0) -> float:
    """Return the Monte Carlo delta estimate for a European call using common random numbers.

    Args:
        S0: Spot price $S_0$.
        K: Strike $K$.
        r: Continuously compounded rate $r$.
        sigma: Volatility $\sigma$.
        T: Time to maturity $T$.
        n_paths: Number of Monte Carlo paths.
        epsilon: Bump size $\varepsilon$ for central difference.
        seed: RNG seed.

    Returns:
        Estimated delta as a float.
    """
    pass

import math
import numpy as np


def mc_delta_call_crn(S0: float, K: float, r: float, sigma: float, T: float, n_paths: int, epsilon: float, seed: int = 0) -> float:
    """Return the Monte Carlo delta estimate for a European call using common random numbers.

    Args:
        S0: Spot price $S_0$.
        K: Strike $K$.
        r: Continuously compounded rate $r$.
        sigma: Volatility $\sigma$.
        T: Time to maturity $T$.
        n_paths: Number of Monte Carlo paths.
        epsilon: Bump size $\varepsilon$ for central difference.
        seed: RNG seed.

    Returns:
        Estimated delta as a float.
    """
    if n_paths <= 0:
        raise ValueError("n_paths must be positive")
    if T < 0.0:
        raise ValueError("T must be nonnegative")
    if sigma < 0.0:
        raise ValueError("sigma must be nonnegative")
    if epsilon <= 0.0:
        raise ValueError("epsilon must be positive")

    if T == 0.0:
        payoff_up = max((S0 + epsilon) - K, 0.0)
        payoff_dn = max((S0 - epsilon) - K, 0.0)
        return (payoff_up - payoff_dn) / (2.0 * epsilon)

    rng = np.random.default_rng(seed)
    Z = rng.standard_normal(n_paths)

    drift = (r - 0.5 * sigma * sigma) * T
    vol = sigma * math.sqrt(T)
    disc = math.exp(-r * T)

    def price_for_spot(spot: float) -> float:
        ST = spot * np.exp(drift + vol * Z)
        payoff = np.maximum(ST - K, 0.0)
        return disc * float(np.mean(payoff))

    v_up = price_for_spot(S0 + epsilon)
    v_dn = price_for_spot(S0 - epsilon)
    return (v_up - v_dn) / (2.0 * epsilon)

JP Morgan's quant research interviews weight numerical implementation over abstract data structure puzzles. The coding round, from what candidates on QuantNet and Reddit report, asks you to translate stochastic calculus or pricing logic into working code under time pressure. Sharpen that skill at datainterview.com/coding.

Test Your Readiness

With ~42% of JP Morgan quant research questions hitting stochastic calculus and probability, knowing exactly where you're weakest saves prep time. Find out at datainterview.com/questions.