Morgan Stanley Quantitative Researcher Interview Guide

Morgan Stanley's Wealth Management division alone oversees $7T+ in client assets, and the quant researchers feeding signals into that machine aren't building toy models. They're building the portfolio construction engines that advisors use to allocate real money across equities, fixed income, and derivatives for millions of accounts.

Morgan Stanley Quantitative Researcher Role

At Morgan Stanley, quantitative researchers operate across two distinct businesses with very different rhythms. On the Institutional Securities side, you're developing alpha signals for equity long/short strategies and credit risk models for the fixed-income derivatives desk. On the Wealth Management side, you're building systematic portfolio construction tools that advisors actually deploy against client capital. The connective tissue is that every signal you produce must survive scrutiny from a PM or risk manager before it touches a dollar, which means your research output isn't a paper or a notebook, it's a recommendation someone bets on.

A Typical Week

What the breakdown won't tell you is how front-loaded the intensity feels. Monday mornings start with PnL reconciliation and model drift checks before the weekly standup, so your sharpest analytical work happens before 9 AM. The writing allocation is real and non-optional: every vetted signal requires a formal methodology doc that PMs reference when sizing positions. Candidates from pure tech backgrounds consistently underestimate how much of this job is persuasion on paper.

Projects & Impact Areas

A typical quarter might have you iterating on a sector-neutral earnings revision signal for the US large-cap equity book, stress-testing turnover constraints and transaction cost assumptions against the firm's proprietary backtester. Meanwhile, the fixed-income quant team is building credit risk signals that feed directly into the Institutional Securities derivatives desk's positioning. Newer workstreams are less defined: some researchers are exploring alternative data sourcing for signals that cut across asset classes, a space where Morgan Stanley's breadth (equities, fixed income, derivatives all under one roof) gives you combinatorial possibilities a single-strategy fund can't offer.

Skills & What's Expected

The math/statistics requirement is rated "expert" for a reason: stochastic calculus and time-series econometrics aren't interview topics you can forget after getting hired. But the skill that separates researchers who get promoted from those who plateau is communication. Morgan Stanley rates data visualization and communication at "high," equal to machine learning, and that reflects the reality of Thursday PM presentations where you'll defend drawdown profiles and regime sensitivity to people who control capital allocation. Python is the primary research language, with R and C# appearing on some teams, but your ability to write a concise three-page research note matters as much as your ability to write clean code.

Levels & Career Growth

Morgan Stanley uses a leveling system running from Analyst through Associate, VP, Executive Director, and Managing Director. From what candidates report, the VP-to-ED transition is where most researchers hit a wall. The difference isn't technical skill. It's whether you've owned a research agenda (not just a single signal) and can point to measurable PnL attribution from work you directed. At senior levels, deferred compensation structures can create golden handcuffs, something to factor in if you're treating MS as a stepping stone to a hedge fund.

Work Culture

The firm requires in-office presence at the Times Square headquarters (1585 Broadway) at least four days a week, and culture notes from the quant teams suggest many default to five given how tightly they sit with trading desks. Expect hours around 7 AM to 6 PM with occasional Sunday evening prep during earnings season, though weekends are largely protected compared to pod-based hedge funds. The collaborative upside is real: cross-desk research sharing and formal presentations mean your work gets seen by people outside your immediate team, which matters for career visibility. The downside is that lone-wolf researchers who want uninterrupted coding time will find the meeting cadence frustrating.

Morgan Stanley Quantitative Researcher Compensation

RSUs vest over several years, and walking away before they fully vest means forfeiting unvested comp. That's the retention mechanism to understand before you sign. Annual bonuses are performance-based, tied to both individual contribution and firm-wide results, so the "target" number your recruiter mentions is exactly that: a target, not a guarantee.

Base salary is the most negotiable component of a Morgan Stanley offer, and the initial RSU grant value has some flexibility too. The bonus target, by contrast, is largely fixed at offer stage. If you want to maximize your first-year package, push on base and RSU grant size together, since those are the levers where recruiters actually have room to move.

Morgan Stanley Quantitative Researcher Interview Process

The full loop runs about six weeks, but what makes this process distinct is how the Super Day (round 3) blends technical depth with behavioral evaluation in a single 4-hour marathon. MS lists "Weak Technical Foundation" as the primary rejection driver, and from what candidates report, that means stumbling on core math and probability more than bombing a coding problem. If your stochastic calculus or hypothesis testing fundamentals are shaky, you won't survive the Super Day's multi-interviewer gauntlet, regardless of how clean your Python is.

One thing most candidates misjudge: the Super Day's behavioral component isn't a separate softball round. It's woven into the same 240-minute onsite that covers stochastic modeling, ML, and finance. Morgan Stanley's 4-day in-office culture and cross-desk research sharing model mean interviewers actively screen for people who can present findings to PMs and traders on the Institutional Securities or Wealth Management desks. Treat every Super Day conversation as if it carries equal weight, because by the time you reach the Hiring Manager Screen (round 4, 30 minutes), the decision is largely made or broken.

Morgan Stanley Quantitative Researcher Interview Questions

import numpy as np
import pandas as pd


def ewma_vol(returns: pd.Series, lam: float = 0.94, min_periods: int = 20) -> pd.Series:
    """EWMA volatility estimate.

    Parameters
    ----------
    returns : pd.Series
        Daily returns indexed by date.
    lam : float
        Decay factor, typical RiskMetrics uses 0.94 for daily.
    min_periods : int
        Require at least this many observations before producing a vol.

    Returns
    -------
    pd.Series
        EWMA volatility (standard deviation) indexed by date.
    """
    r2 = returns.astype(float).pow(2)

    # EWMA variance recursion: v_t = lam * v_{t-1} + (1-lam) * r_t^2
    # Use adjust=False to match the standard recursion.
    var = r2.ewm(alpha=(1.0 - lam), adjust=False, min_periods=min_periods).mean()
    vol = np.sqrt(var)
    return vol


def max_drawdown(equity_curve: pd.Series) -> float:
    """Compute max drawdown from an equity curve."""
    ec = equity_curve.astype(float)
    running_max = ec.cummax()
    dd = ec / running_max - 1.0
    return float(dd.min())


def vol_target_backtest(
    close: pd.Series,
    rf_1d: pd.Series,
    sigma_target_annual: float = 0.10,
    lam: float = 0.94,
    max_lev: float = 3.0,
    min_periods: int = 20,
    trading_days: int = 252,
) -> tuple[pd.DataFrame, dict]:
    """Walk-forward backtest for a vol-targeted single-asset strategy.

    Strategy
    --------
    - Compute daily simple returns r_t.
    - Estimate EWMA daily vol \hat{\sigma}_t from returns up to t.
    - Set position for day t as lev_t = min(sigma_target_daily / \hat{\sigma}_{t-1}, max_lev).
      This uses \hat{\sigma} as of t-1 to avoid lookahead.
    - Strategy excess return: lev_t * (r_t - rf_t).

    Returns
    -------
    (df, stats)
        df includes position, returns, turnover, and equity curve.
        stats includes Sharpe and max drawdown.
    """
    close = close.dropna().astype(float)
    rf_1d = rf_1d.reindex(close.index).fillna(0.0).astype(float)

    # Daily simple returns
    ret = close.pct_change()

    # Excess returns (align to ret index)
    ex_ret = ret - rf_1d

    # EWMA vol estimate using returns up to each date
    vol = ewma_vol(ret, lam=lam, min_periods=min_periods)

    # Convert annual target to daily target
    sigma_target_daily = sigma_target_annual / np.sqrt(trading_days)

    # Position for day t uses vol_{t-1} (no lookahead)
    vol_lag = vol.shift(1)
    raw_lev = sigma_target_daily / vol_lag
    pos = raw_lev.clip(upper=max_lev)

    # If vol estimate is missing, hold zero risk (flat)
    pos = pos.where(np.isfinite(pos), other=0.0).fillna(0.0)

    # Strategy returns
    strat_excess = pos * ex_ret
    strat_excess = strat_excess.fillna(0.0)

    # Turnover as absolute change in position
    turnover = pos.diff().abs().fillna(0.0)

    # Equity curve from excess returns
    equity = (1.0 + strat_excess).cumprod()

    # Performance metrics
    # Annualized Sharpe from daily excess returns
    mean_d = strat_excess.mean()
    std_d = strat_excess.std(ddof=1)
    sharpe = float(np.sqrt(trading_days) * mean_d / std_d) if std_d > 0 else np.nan

    mdd = max_drawdown(equity)

    df = pd.DataFrame(
        {
            "close": close,
            "ret": ret,
            "rf_1d": rf_1d,
            "excess_ret": ex_ret,
            "ewma_vol": vol,
            "position": pos,
            "strategy_excess_ret": strat_excess,
            "turnover": turnover,
            "equity": equity,
        }
    )

    stats = {
        "annualized_sharpe": sharpe,
        "max_drawdown": mdd,
        "cumulative_return": float(equity.iloc[-1] - 1.0) if len(equity) else np.nan,
    }

    return df, stats


if __name__ == "__main__":
    # Minimal example with synthetic data
    idx = pd.date_range("2020-01-01", periods=300, freq="B")
    rng = np.random.default_rng(0)
    # Simulate geometric random walk
    daily_r = rng.normal(0.0002, 0.01, size=len(idx))
    close = pd.Series(100.0 * np.cumprod(1.0 + daily_r), index=idx)
    rf = pd.Series(0.00001, index=idx)  # 1 bp daily risk-free

    df, stats = vol_target_backtest(close, rf, sigma_target_annual=0.10)
    print(stats)
    print(df.tail())

from __future__ import annotations

from collections import defaultdict, deque
from dataclasses import dataclass
from typing import Deque, Dict, Optional, Tuple


@dataclass
class _SymbolState:
    """Per-symbol rolling state for the last K trades."""

    trades: Deque[Tuple[float, float]]  # (price, size)
    sum_pq: float
    sum_q: float


class RollingVWAP:
    """Maintain per-symbol VWAP over the last K trades (count-based window)."""

    def __init__(self, k: int):
        if k <= 0:
            raise ValueError("k must be a positive integer")
        self.k = k
        self._state: Dict[str, _SymbolState] = {}

    def update(self, symbol: str, price: float, size: float, ts: object = None) -> Optional[float]:
        """Process one trade and return the current rolling VWAP for `symbol`.

        Returns None if the total size in the window is 0.
        Note: ts is accepted for realism but unused because the window is trade-count based.
        """
        if size < 0:
            raise ValueError("size must be non-negative")

        st = self._state.get(symbol)
        if st is None:
            st = _SymbolState(trades=deque(), sum_pq=0.0, sum_q=0.0)
            self._state[symbol] = st

        # Add the new trade.
        st.trades.append((price, size))
        st.sum_pq += price * size
        st.sum_q += size

        # Evict if window exceeds K trades.
        if len(st.trades) > self.k:
            old_p, old_q = st.trades.popleft()
            st.sum_pq -= old_p * old_q
            st.sum_q -= old_q

        # Compute VWAP.
        if st.sum_q == 0:
            return None
        return st.sum_pq / st.sum_q

from __future__ import annotations

from collections import deque
from typing import Deque, List


def min_len_subarray_sum_at_least_t(exposures: List[float], t: float) -> int:
    """Return the minimum length of a contiguous subarray with sum >= t.

    Works with negative values using prefix sums and a monotonic deque.
    Time: O(N), Space: O(N)
    """
    n = len(exposures)
    if n == 0:
        return 0

    # Prefix sums P where P[i] = sum(exposures[0:i]).
    prefix = [0.0] * (n + 1)
    for i, x in enumerate(exposures, start=1):
        prefix[i] = prefix[i - 1] + x

    # Deque of indices with increasing prefix values.
    dq: Deque[int] = deque()
    ans = n + 1

    for j in range(n + 1):
        # Try to shrink from the left while the sum constraint holds.
        while dq and prefix[j] - prefix[dq[0]] >= t:
            ans = min(ans, j - dq[0])
            dq.popleft()

        # Maintain increasing prefix values in dq.
        while dq and prefix[j] <= prefix[dq[-1]]:
            dq.pop()

        dq.append(j)

    return 0 if ans == n + 1 else ans

/*
Goal:
- Pull AAPL daily closes in 2023
- Apply split adjustments using equities_actions
- Compute 1-day return on adjusted close
- Flag |return| > 30%

Assumptions:
- equities_actions.split_factor is the split ratio applied on action_date, e.g., 4.0 for a 4-for-1 split.
- Adjustment is applied to historical comparability by dividing close by cumulative product of split_factors effective on or before the trade_date.
*/
WITH aapl_prices AS (
    SELECT
        p.trade_date,
        p.symbol,
        p.close_px
    FROM equities_prices p
    WHERE p.symbol = 'AAPL'
      AND p.trade_date >= DATE '2023-01-01'
      AND p.trade_date <  DATE '2024-01-01'
),
-- For each price date, collect all splits effective on or before that date.
per_day_split_factors AS (
    SELECT
        ap.trade_date,
        ap.symbol,
        COALESCE(a.split_factor, 1.0) AS split_factor
    FROM aapl_prices ap
    LEFT JOIN equities_actions a
      ON a.symbol = ap.symbol
     AND a.action_date <= ap.trade_date
),
-- Compute cumulative product of split factors per day.
-- Using exp(sum(ln(x))) is a common pattern; ensure split_factor > 0 in real data.
per_day_cum_adj AS (
    SELECT
        trade_date,
        symbol,
        EXP(SUM(LN(split_factor))) AS cum_split_factor
    FROM per_day_split_factors
    GROUP BY trade_date, symbol
),
adjusted AS (
    SELECT
        ap.trade_date,
        ap.symbol,
        ap.close_px,
        c.cum_split_factor,
        ap.close_px / NULLIF(c.cum_split_factor, 0.0) AS adj_close_px
    FROM aapl_prices ap
    JOIN per_day_cum_adj c
      ON c.trade_date = ap.trade_date
     AND c.symbol = ap.symbol
),
with_returns AS (
    SELECT
        trade_date,
        symbol,
        close_px,
        adj_close_px,
        (adj_close_px / NULLIF(LAG(adj_close_px) OVER (PARTITION BY symbol ORDER BY trade_date), 0.0)) - 1.0 AS ret_1d
    FROM adjusted
)
SELECT
    trade_date,
    symbol,
    close_px,
    adj_close_px,
    ret_1d,
    CASE
        WHEN ret_1d IS NULL THEN 0
        WHEN ABS(ret_1d) > 0.30 THEN 1
        ELSE 0
    END AS flag_abs_ret_gt_30pct
FROM with_returns
ORDER BY trade_date;

Math and finance questions don't just dominate the count here; they compound each other in ways that trip up candidates who studied them separately. A probability question about Poisson arrivals becomes much harder when you also need to reason about corporate bond market microstructure, and an options Greeks question assumes you can derive the underlying stochastic model on the fly. The most common prep mistake, from what candidates report, is over-indexing on algorithms and SQL while neglecting the finance fluency that Morgan Stanley's desk-aligned interview panels specifically probe for (think duration dynamics, factor model drift, or walk-forward validation pitfalls tied to real MS trading books).

Practice across every category at datainterview.com/questions.

How to Prepare for Morgan Stanley Quantitative Researcher Interviews

Morgan Stanley's 2025 investment themes center on AI-driven disruption and digital assets, with the firm recruiting lead engineers to build out a tokenization platform and crypto wallet infrastructure targeting late 2026. For quant researchers, that translates to expanding signal work across Institutional Securities while the Wealth Management side pushes systematic portfolio construction into newer asset classes. The firm's $70.3 billion in revenue with 11% year-over-year growth gives it real budget to fund these bets.

Where most "why Morgan Stanley" answers fall flat is in failing to connect to anything the firm is actually doing right now. Don't talk about breadth or prestige. Name a specific initiative, like their open-source CALM architecture framework or the tokenization hiring push, and explain why that particular problem excites you more than running a single strategy at a buy-side pod shop.

Reference their Q4 2025 earnings report to show you've done homework that goes beyond the "About Us" page. That level of specificity signals you're interviewing at Morgan Stanley on purpose, not as a backup.

Try a Real Interview Question

import numpy as np


def ic_mean_newey_west_t(factors: np.ndarray, returns: np.ndarray, lag: int = 5) -> tuple[float, float]:
    """Compute mean daily Spearman IC and Newey-West t-statistic.

    Parameters
    ----------
    factors : np.ndarray
        Array of shape (T, N) with factor values, may contain np.nan.
    returns : np.ndarray
        Array of shape (T, N) with next-period returns, may contain np.nan.
    lag : int
        Newey-West lag length L >= 0.

    Returns
    -------
    (mean_ic, t_stat) : tuple[float, float]
        Mean daily IC and Newey-West t-statistic for mean_ic.
    """
    pass

import numpy as np


def _rankdata_average_ties(x: np.ndarray) -> np.ndarray:
    """Ranks 1..n with average ranks for ties. x must be 1d, finite."""
    n = x.size
    order = np.argsort(x, kind="mergesort")
    xs = x[order]
    ranks_sorted = np.empty(n, dtype=float)

    i = 0
    while i < n:
        j = i + 1
        while j < n and xs[j] == xs[i]:
            j += 1
        avg_rank = 0.5 * ((i + 1) + j)
        ranks_sorted[i:j] = avg_rank
        i = j

    ranks = np.empty(n, dtype=float)
    ranks[order] = ranks_sorted
    return ranks


def _spearman_corr(a: np.ndarray, b: np.ndarray) -> float:
    """Spearman correlation for 1d arrays a, b of same length, finite."""
    n = a.size
    if n < 2:
        return np.nan

    ra = _rankdata_average_ties(a)
    rb = _rankdata_average_ties(b)

    ra = ra - ra.mean()
    rb = rb - rb.mean()

    denom = np.sqrt(np.dot(ra, ra) * np.dot(rb, rb))
    if denom == 0.0:
        return np.nan
    return float(np.dot(ra, rb) / denom)


def _newey_west_se_of_mean(x: np.ndarray, lag: int) -> float:
    """Newey-West standard error of the sample mean of x (demeaned internally)."""
    t = x.size
    if t < 2:
        return np.nan

    lag = int(lag)
    if lag < 0:
        raise ValueError("lag must be >= 0")
    lag = min(lag, t - 1)

    mu = x.mean()
    u = x - mu

    gamma0 = np.dot(u, u) / t
    s = gamma0

    for l in range(1, lag + 1):
        w = 1.0 - l / (lag + 1.0)
        gl = np.dot(u[l:], u[:-l]) / t
        s += 2.0 * w * gl

    var_mean = s / t
    if var_mean <= 0.0 or not np.isfinite(var_mean):
        return np.nan
    return float(np.sqrt(var_mean))


def ic_mean_newey_west_t(factors: np.ndarray, returns: np.ndarray, lag: int = 5) -> tuple[float, float]:
    """Compute mean daily Spearman IC and Newey-West t-statistic.

    Parameters
    ----------
    factors : np.ndarray
        Array of shape (T, N) with factor values, may contain np.nan.
    returns : np.ndarray
        Array of shape (T, N) with next-period returns, may contain np.nan.
    lag : int
        Newey-West lag length L >= 0.

    Returns
    -------
    (mean_ic, t_stat) : tuple[float, float]
        Mean daily IC and Newey-West t-statistic for mean_ic.
    """
    f = np.asarray(factors, dtype=float)
    r = np.asarray(returns, dtype=float)

    if f.ndim != 2 or r.ndim != 2 or f.shape != r.shape:
        raise ValueError("factors and returns must be 2D arrays with the same shape")

    t, n = f.shape
    if t == 0 or n == 0:
        return (float("nan"), float("nan"))

    ics = []
    for i in range(t):
        fi = f[i]
        ri = r[i]
        mask = np.isfinite(fi) & np.isfinite(ri)
        if mask.sum() < 2:
            continue
        ic = _spearman_corr(fi[mask], ri[mask])
        if np.isfinite(ic):
            ics.append(ic)

    if len(ics) < 2:
        return (float("nan"), float("nan"))

    x = np.array(ics, dtype=float)
    mean_ic = float(x.mean())

    se = _newey_west_se_of_mean(x, lag=lag)
    if not np.isfinite(se) or se == 0.0:
        return (mean_ic, float("nan"))

    t_stat = float(mean_ic / se)
    return (mean_ic, t_stat)

Morgan Stanley's coding problems lean toward applied financial computing rather than textbook algorithm puzzles. You'll write Python that touches real data workflows, so comfort with pandas and numpy matters more than memorizing sorting algorithms. Build that fluency at datainterview.com/coding.

Test Your Readiness

The widget above shows where you're strong and where you're exposed. Close the gaps at datainterview.com/questions, starting with whichever category surprised you most.