AQR Quantitative Researcher Interview Guide

AQR's interview loop for Quantitative Researcher leans harder on statistics and probability than most quant hedge fund processes, with those two areas accounting for roughly 40% of question weight. That tilt reflects something real about the job itself: your value here comes from written research that holds up under scrutiny, not from shipping features or optimizing latency.

AQR Quantitative Researcher Role

You'll spend your days building, testing, and defending systematic trading signals across AQR's strategies. Success after year one means you've contributed at least one signal to the live factor library, your internal research memos reach senior decision-makers without heavy redlines, and you can field pointed questions in the weekly PnL meeting about why a signal underperformed during a regime shift. The output that matters is a research conclusion backed by rigorous statistical evidence, written clearly enough to change how capital gets allocated.

A Typical Week

The widget shows the time split, but what it doesn't convey is the texture. Analysis and research dominate your calendar, yet those blocks aren't quiet solo work. They involve pulling up AQR's proprietary risk dashboards, slicing returns across sectors and geographies to diagnose signal decay, and prototyping new cross-sectional factors against the internal backtesting framework. The writing block is the one most candidates underestimate: internal memos here mirror the rigor of AQR's published white papers, complete with charts, statistical tests, and explicit recommendations that circulate to the CIO's office.

Projects & Impact Areas

Signal research on alternative data sources (satellite-derived supply chain activity, for instance) sits alongside risk modeling work that shapes position sizing and hedging across strategies. These threads connect: you might prototype a new factor on Tuesday, write the memo recommending a weight change on a decaying momentum signal Wednesday, and present preliminary results to a strategy head Thursday who decides whether real capital follows your conclusion.

Skills & What's Expected

Derivation-from-scratch ability in math and statistics is the skill most applicants underprepare relative to how heavily AQR tests it. Interviewers expect you to reason about estimators and asymptotics on a whiteboard, not just reference library functions. Python (pandas, numpy, statsmodels) and C++ are the working languages, and the day-in-life data confirms you'll do real code review and refactoring into production-grade modules. But the less obvious bar is economic reasoning: AQR wants to hear why a signal should work, grounded in financial theory, not just that it survived a backtest.

Levels & Career Growth

The widget shows the level bands. What it won't tell you is that the promotion blocker at mid-career levels, from what candidates and AQR employees report, isn't technical skill. It's research ownership. Can you independently identify a question worth pursuing, run the full investigation, and defend your conclusion to senior PMs who will stress-test your methodology? AQR's relatively flat culture means junior researchers can influence senior thinking if the analysis is airtight, but advancing requires demonstrating you drive a research agenda rather than execute someone else's.

Work Culture

AQR's Greenwich headquarters expects four to five days on-site, which is stricter than tech but standard for quant funds. Days run roughly 7 AM to 6 PM, with weekends mostly protected unless markets are in crisis. The culture prizes intellectual rigor and written precision. Internal seminars feature vigorous Q&A where colleagues challenge each other's work openly. The honest downside: you'll spend more time wordsmithing memos than you might expect, and the in-office expectation leaves little room for the remote flexibility common at tech companies.

AQR Quantitative Researcher Compensation

AQR's pay leans heavily toward cash: base salary plus a discretionary annual bonus tied to firm and team performance. Long-term incentives may exist for some roles, but they're less standardized than big-tech RSUs, and the firm doesn't volunteer details about how (or whether) they apply to your specific offer. The biggest gotcha is that ongoing bonus percentages are nearly impossible to lock in upfront, so your year-over-year comp will carry real uncertainty.

Where you do have leverage: base salary and a guaranteed first-year bonus. From what candidates report, competing offers from peer quant firms meaningfully strengthen your position on both. Don't stop at cash, though. Clarify whether you'll own a research agenda or support someone else's, and ask about the firm's conference and publishing policy, since AQR's public research output (their white papers on factor investing, economic trends) is a real career asset if you're allowed to contribute.

AQR Quantitative Researcher Interview Process

The loop moves fast, so don't let prep lag behind your scheduling. Weak statistical foundations are the most frequently cited rejection reason, ahead of coding or modeling gaps. Candidates who can build a gradient-boosted model but can't derive the bias of an estimator under violated assumptions tend to stall in the technical rounds. Weight your prep hours accordingly: probability and statistics deserve the lion's share.

AQR's evaluation puts communication on nearly equal footing with correctness. Getting defensive when an interviewer pokes a hole in your derivation, or bluffing through a gap instead of saying "I'm not sure, but here's my approach," can sink an otherwise strong performance. The behavioral round at the end isn't a cooldown lap; candidates who can't narrate a research failure with genuine self-awareness report getting stuck there.

AQR Quantitative Researcher Interview Questions

from __future__ import annotations

from typing import List, Optional
import math


def rolling_cross_sectional_zscores(
    prices: List[List[Optional[float]]], window: int = 20
) -> List[List[Optional[float]]]:
    """Compute rolling cross-sectional z-scores of 1-day returns.

    Args:
        prices: Matrix of closes, shape (T, N). Missing values are None.
        window: Rolling window length in days for returns (uses last `window` returns).

    Returns:
        Matrix of z-scores, shape (T, N). For day t, z-score is computed across assets
        using the return from t-1 to t, but only if that return exists. If fewer than 2
        assets have valid returns on day t, all outputs for that day are None.

    Notes:
        - Return is simple return: r[t,i] = price[t,i]/price[t-1,i] - 1.
        - Window parameter is included to match the prompt, but cross-sectional z-score
          is computed per day on the 1-day return. The rolling aspect is across days in
          the output; no time-series normalization is applied.
    """
    if not prices:
        return []

    T = len(prices)
    N = len(prices[0]) if T > 0 else 0
    for row in prices:
        if len(row) != N:
            raise ValueError("All rows must have the same number of assets (N).")

    # Compute 1-day returns r[t][i] for t>=1.
    returns: List[List[Optional[float]]] = [[None] * N for _ in range(T)]
    for t in range(1, T):
        for i in range(N):
            p0 = prices[t - 1][i]
            p1 = prices[t][i]
            if p0 is None or p1 is None or p0 == 0:
                returns[t][i] = None
            else:
                returns[t][i] = p1 / p0 - 1.0

    # For each day, compute cross-sectional z-score of that day's 1-day returns.
    z: List[List[Optional[float]]] = [[None] * N for _ in range(T)]
    for t in range(T):
        # In many pipelines you might only start output after enough history.
        # Here, keep it simple: z-score depends only on day t cross-section.
        vals = [r for r in returns[t] if r is not None]
        if len(vals) < 2:
            continue

        mean = sum(vals) / len(vals)
        # Population std for cross-section.
        var = sum((v - mean) ** 2 for v in vals) / len(vals)
        std = math.sqrt(var)
        if std == 0.0:
            # All same return, define z-scores as 0 for valid entries.
            for i in range(N):
                if returns[t][i] is not None:
                    z[t][i] = 0.0
            continue

        for i in range(N):
            r = returns[t][i]
            if r is None:
                z[t][i] = None
            else:
                z[t][i] = (r - mean) / std

    return z

import numpy as np
import pandas as pd

# df columns: date, asset_id, ret, mkt_cap, sector
# Assumes ret is the return from close t-1 to close t, and mkt_cap is known at date t (same close).
# If mkt_cap is from close t, it is safe for weighting same-day realized returns in backtests that trade at close.

def value_weighted_sector_and_neutralized(df: pd.DataFrame) -> pd.DataFrame:
    df = df.copy()
    df["date"] = pd.to_datetime(df["date"])

    # Clean weights
    df["mkt_cap"] = pd.to_numeric(df["mkt_cap"], errors="coerce")
    df["ret"] = pd.to_numeric(df["ret"], errors="coerce")

    valid = df["mkt_cap"].notna() & (df["mkt_cap"] > 0) & df["ret"].notna() & df["sector"].notna()
    df_valid = df.loc[valid, ["date", "asset_id", "sector", "ret", "mkt_cap"]]

    # Value-weighted sector return per day
    g = df_valid.groupby(["date", "sector"], sort=False)
    sector_ret = (g.apply(lambda x: np.average(x["ret"].to_numpy(), weights=x["mkt_cap"].to_numpy()))
                    .rename("sector_ret")
                    .reset_index())

    out = df.merge(sector_ret, on=["date", "sector"], how="left")
    out["ret_sector_neutral"] = out["ret"] - out["sector_ret"]
    return out

import numpy as np
import pandas as pd

# df columns: date, asset_id, ret, signal
# ret is daily close-to-close return for that date.

def decile_long_short_next_month(df: pd.DataFrame) -> pd.DataFrame:
    df = df.copy()
    df["date"] = pd.to_datetime(df["date"])
    df = df.sort_values(["asset_id", "date"])

    df["ret"] = pd.to_numeric(df["ret"], errors="coerce")
    df["signal"] = pd.to_numeric(df["signal"], errors="coerce")

    # Identify month-end dates present in your dataset
    df["month"] = df["date"].dt.to_period("M")
    month_end = df.groupby("month")["date"].max().rename("month_end_date")
    df = df.merge(month_end, on="month", how="left")
    df["is_month_end"] = df["date"].eq(df["month_end_date"])

    # Build positions at month-end using only same-day signal
    me = df.loc[df["is_month_end"], ["date", "asset_id", "signal"]].dropna(subset=["signal"]).copy()

    def assign_deciles(x: pd.DataFrame) -> pd.DataFrame:
        # Robust ranking with ties
        r = x["signal"].rank(method="first", ascending=True)
        x = x.assign(_rank=r)
        x["decile"] = pd.qcut(x["_rank"], 10, labels=False) + 1
        return x.drop(columns=["_rank"])

    me = me.groupby("date", group_keys=False).apply(assign_deciles)

    # +1 for top decile, -1 for bottom decile, 0 otherwise
    me["pos"] = 0.0
    me.loc[me["decile"] == 10, "pos"] = 1.0
    me.loc[me["decile"] == 1, "pos"] = -1.0

    # Equal-weight within each side
    def ew_within_side(x: pd.DataFrame) -> pd.DataFrame:
        longs = x["pos"] == 1
        shorts = x["pos"] == -1
        x = x.copy()
        if longs.any():
            x.loc[longs, "w"] = 1.0 / longs.sum()
        if shorts.any():
            x.loc[shorts, "w"] = -1.0 / shorts.sum()
        x["w"] = x["w"].fillna(0.0)
        return x

    me["w"] = np.nan
    me = me.groupby("date", group_keys=False).apply(ew_within_side)

    # Carry weights forward until next month-end. Use merge_asof per asset.
    me_w = me[["date", "asset_id", "w"]].sort_values(["asset_id", "date"])

    df2 = df[["date", "asset_id", "ret"]].sort_values(["asset_id", "date"])

    # For each asset, assign the most recent month-end weight as of current date.
    df2 = pd.merge_asof(
        df2,
        me_w,
        by="asset_id",
        on="date",
        direction="backward",
        allow_exact_matches=True,
    )

    # Only apply weight after it is formed, so start next trading day.
    # Compute formation date per asset (the date of weight assignment) and zero weight on formation date itself.
    df2 = df2.merge(me_w.rename(columns={"date": "form_date"}), on=["asset_id", "w"], how="left")
    df2.loc[df2["date"].eq(df2["form_date"]), "w"] = 0.0
    df2 = df2.drop(columns=["form_date"])

    # Delist-safe handling: missing returns treated as 0 only if you explicitly choose that convention.
    # Here: treat missing ret as 0 return for that day (cash), but keep weight.
    df2["ret_filled"] = df2["ret"].fillna(0.0)

    df2["pnl"] = df2["w"].fillna(0.0) * df2["ret_filled"]
    port = df2.groupby("date", as_index=False)["pnl"].sum().rename(columns={"pnl": "ls_ret"})

    return port

AQR's question mix mirrors a firm that built its reputation on published factor research and economic reasoning, not black-box prediction. The compounding difficulty comes where pen-and-paper derivation meets financial context: the stats and probability questions don't exist in a vacuum, they're grounded in scenarios like testing whether a value signal is just a disguised beta tilt or sizing a long-short book against realistic transaction costs, which means you can't compartmentalize your prep. Candidates who spend most of their time on tree-based model tuning and algorithm puzzles tend to underweight the derivation-heavy rounds that AQR's factor-research culture puts front and center.

Practice these question types and hundreds more at datainterview.com/questions.

How to Prepare for AQR Quantitative Researcher Interviews

AQR roared back to $179 billion in assets under management as of late 2025, driven by factor strategies (value, momentum, carry, defensive) applied across equities, macro, and alternatives. Newer products like the long-or-short S&P 500 fusion fund show the firm is still expanding its systematic toolkit, which means quant researchers aren't just maintaining legacy models.

What separates AQR from other large systematic firms is how publicly it stakes out intellectual positions. Cliff Asness's team publishes research on economic trend following and equity market neutral construction that most competitors would keep proprietary. As a researcher, you're expected to engage with that body of work, extend it, and sometimes argue against it internally.

The "why AQR" answer that falls flat is any version of "I want to work at a top quant fund." Swap in Citadel or Two Sigma and the sentence still works, which is exactly the problem. Pick a specific AQR white paper, explain what you found compelling or where you'd push back, and tie it to your own research interests. That tells interviewers you chose AQR for its intellectual identity, not its brand.

Try a Real Interview Question

def neutralize_returns(r, X, w):
    """Return factor-neutral residuals from a weighted least squares regression.

    Parameters
    ----------
    r : list[float]
        Length-n vector of returns.
    X : list[list[float]]
        n by k matrix of factor exposures.
    w : list[float]
        Length-n vector of strictly positive weights.

    Returns
    -------
    list[float]
        Length-n vector of residual returns epsilon = r - X beta_hat.
    """
    pass

def neutralize_returns(r, X, w):
    """Return factor-neutral residuals from a weighted least squares regression.

    Parameters
    ----------
    r : list[float]
        Length-n vector of returns.
    X : list[list[float]]
        n by k matrix of factor exposures.
    w : list[float]
        Length-n vector of strictly positive weights.

    Returns
    -------
    list[float]
        Length-n vector of residual returns epsilon = r - X beta_hat.
    """
    if r is None or X is None or w is None:
        raise ValueError("r, X, and w must be provided")

    n = len(r)
    if n == 0:
        return []

    if len(w) != n or len(X) != n:
        raise ValueError("Length mismatch: r, X, and w must have the same number of rows")

    k = len(X[0]) if n > 0 else 0
    for i in range(n):
        if len(X[i]) != k:
            raise ValueError("All rows of X must have the same number of columns")
        if w[i] <= 0:
            raise ValueError("All weights must be strictly positive")

    # Build A = X^T W X and b = X^T W r
    A = [[0.0 for _ in range(k)] for __ in range(k)]
    b = [0.0 for _ in range(k)]

    for i in range(n):
        wi = float(w[i])
        ri = float(r[i])
        xi = X[i]
        for j in range(k):
            xij = float(xi[j])
            b[j] += xij * wi * ri
            for l in range(k):
                A[j][l] += xij * wi * float(xi[l])

    def mat_inv_or_pinv(M):
        """Return inverse of square matrix M if possible else Moore-Penrose pseudoinverse.

        Uses Gauss-Jordan with partial pivoting for inverse; falls back to pseudoinverse
        computed from SVD when singular or near-singular.
        """
        m = len(M)
        if m == 0:
            return []
        for row in M:
            if len(row) != m:
                raise ValueError("Matrix must be square")

        # Attempt Gauss-Jordan inversion.
        A_loc = [list(map(float, row)) for row in M]
        I = [[0.0] * m for _ in range(m)]
        for i in range(m):
            I[i][i] = 1.0

        eps = 1e-12
        for col in range(m):
            # Partial pivoting.
            pivot_row = max(range(col, m), key=lambda r: abs(A_loc[r][col]))
            pivot_val = A_loc[pivot_row][col]
            if abs(pivot_val) < eps:
                A_loc = None
                break
            if pivot_row != col:
                A_loc[col], A_loc[pivot_row] = A_loc[pivot_row], A_loc[col]
                I[col], I[pivot_row] = I[pivot_row], I[col]

            inv_pivot = 1.0 / A_loc[col][col]
            for j in range(m):
                A_loc[col][j] *= inv_pivot
                I[col][j] *= inv_pivot

            for r in range(m):
                if r == col:
                    continue
                factor = A_loc[r][col]
                if factor == 0.0:
                    continue
                for j in range(m):
                    A_loc[r][j] -= factor * A_loc[col][j]
                    I[r][j] -= factor * I[col][j]

        if A_loc is not None:
            return I

        # Fallback: pseudoinverse via SVD using numpy if available.
        try:
            import numpy as np

            Mnp = np.asarray(M, dtype=float)
            U, s, Vt = np.linalg.svd(Mnp, full_matrices=False)
            tol = np.max(Mnp.shape) * np.max(s) * 1e-12 if s.size else 0.0
            s_inv = np.array([1.0 / si if si > tol else 0.0 for si in s], dtype=float)
            M_pinv = (Vt.T * s_inv) @ U.T
            return M_pinv.tolist()
        except Exception:
            raise ValueError("Matrix is singular and pseudoinverse requires numpy")

    A_inv = mat_inv_or_pinv(A)

    # beta = A_inv @ b
    beta = [0.0 for _ in range(k)]
    for i in range(k):
        s = 0.0
        row = A_inv[i]
        for j in range(k):
            s += row[j] * b[j]
        beta[i] = s

    # residuals = r - X beta
    epsil = [0.0 for _ in range(n)]
    for i in range(n):
        xb = 0.0
        xi = X[i]
        for j in range(k):
            xb += float(xi[j]) * beta[j]
        epsil[i] = float(r[i]) - xb

    return epsil

AQR's coding rounds, based on candidate reports on QuantNet, lean toward empirical research fluency over competitive programming tricks. The firm cares whether you can move from a statistical idea to clean, testable Python. Practice these patterns at datainterview.com/coding, prioritizing the statistics and time-series categories.

Test Your Readiness

The quiz above mirrors the areas where AQR's interview loop hits hardest. Identify your weak spots here, then target them at datainterview.com/questions.