Goldman Sachs Data Scientist Interview Guide

Goldman Sachs screens for behavioral fit and stakeholder communication across multiple touchpoints in its data scientist interview loop. If you're the type who preps only for the ML round and wings the "tell me about a time" questions, you're making a mistake that costs a lot of otherwise strong candidates.

Goldman Sachs Data Scientist Role

You're building models inside Goldman's Asset Management division that feed directly into how portfolio managers make decisions. That means portfolio construction signals, credit risk scoring with feature engineering in PySpark on Databricks, and client segmentation work that shapes rebalancing strategies. Success in year one looks like getting a model through GS's independent Model Risk Management validation and into production where a PM actually acts on the output, not leaving it in a notebook.

A Typical Week

The surprise isn't the modeling time. It's how much of your week disappears into documentation, governance memos, and stakeholder decks. If you're coming from a startup or a tech company where "ship it and iterate" was the ethos, the regulatory overhead at GS will feel like a second job. Debugging an Airflow DAG failure on an upstream data feed one afternoon, then translating Shapley values into PM-friendly language the next morning: that's the actual rhythm.

Projects & Impact Areas

Portfolio rebalancing signal models anchor the Asset Management DS team's work, with your outputs going straight into presentations where you explain lift curves in terms PMs care about. Credit risk scoring runs in parallel, pulling from counterparty exposure tables, and those model outputs feed capital reserve calculations and trading desk decisions. GS is also deploying LLM-based tools for earnings summarization and compliance document analysis, and the firm's skill expectations reflect a real strategic push into GenAI and modern AI, so you'll be building with these tools, not just evaluating them from the sidelines.

Skills & What's Expected

Software engineering is the most underrated skill for this role. Candidates pour prep time into ML theory and statistics, which absolutely matter here, but GS expects you to ship production code, review PRs, and work within deployment pipelines on their modernized tech stack (think GraalVM adoption, the open-source Legend platform). The flip side: financial fluency is where most tech-background candidates fall short. If you can't explain what a basis point move means for a portfolio or why a sparse feature set in credit risk might call for L1 over L2 regularization, your technical depth won't compensate.

Levels & Career Growth

The VP-to-Executive Director promotion is where careers stall. Strong individual contributor work isn't enough at that threshold. You need visible cross-divisional impact and sponsorship from at least one MD. Internal mobility between divisions (Asset Management to Global Markets, for example) requires a formal internal application and your current manager's sign-off, which creates enough friction that many people stay in their lane longer than they'd planned.

Work Culture

Goldman expects consistent in-office presence five days a week at 200 West Street, and CEO David Solomon has been publicly vocal about prioritizing in-person culture. Slack threads run until 7 or 8 PM during quarter-end pushes, and your methodology gets scrutinized in regular readout sessions with MRM validators and senior PMs who won't nod politely if your backtesting looks thin. The feedback loop is fast because of that scrutiny, but the documentation and governance burden that comes with operating under regulatory oversight will feel heavy if you've never worked in financial services before.

Goldman Sachs Data Scientist Compensation

GS comp is a bonus-driven machine. Your annual discretionary bonus is the real variable, tied to both individual and firm performance, and it's not guaranteed money. Senior roles may include RSUs, but for most data scientists the cash bonus is where the action is.

Base salary is negotiable, so don't leave that on the table. The source of real leverage, though, is a competing offer, which can help you push for a stronger sign-on bonus. Spend your negotiation energy on those two levers: base and sign-on.

Goldman Sachs Data Scientist Interview Process

The HireVue screen is AI-conducted and recorded, which means your first impression at GS happens without a human in the room. Candidates who treat it as a throwaway often don't advance to the live coding round, where you'll write production-quality solutions under time pressure on GS's preferred data structures and algorithm problems. Among the most common rejection reasons candidates report: lacking technical depth on algorithms and failing to clearly walk interviewers through their reasoning, and both of these get tested before you ever reach the Superday.

The Superday itself packs a second behavioral round, an ML and modeling deep-dive, and a finance-flavored case study into a single day. That second behavioral isn't redundant. GS's 14 Business Principles (client service, integrity, excellence) aren't just wall art; interviewers in that round probe whether your stakeholder communication and values alignment hold up under scrutiny from a different interviewer than the one who screened you initially. Post-Superday, from what candidates report, the wait for a final answer can stretch beyond the typical timeline if division leadership needs to weigh in on headcount or competing candidates.

Goldman Sachs Data Scientist Interview Questions

from __future__ import annotations

from dataclasses import dataclass
from typing import Dict, Iterable, Optional, Tuple


@dataclass(frozen=True)
class Trade:
    ts: int  # epoch millis or any comparable integer timestamp
    symbol: str
    size: float


def first_symbol_to_cross_threshold(
    trades: Iterable[Trade],
    T: float,
) -> Optional[Tuple[str, int]]:
    """Return (symbol, ts) for the first symbol whose cumulative size exceeds T.

    Assumptions:
      - trades arrive in non-decreasing timestamp order (streaming ingestion).
      - crossing means cumulative_size > T (strictly exceeds).
      - If multiple symbols cross at the same timestamp, return the one that crossed
        at that timestamp first in the input order (stable tie-break).

    Time: O(n)
    Space: O(k) where k is number of distinct symbols
    """
    if T < 0:
        # If threshold is negative, any positive cumulative would exceed immediately.
        # But to keep semantics sane, treat it as already exceeded by first trade.
        for tr in trades:
            return (tr.symbol, tr.ts)
        return None

    cum: Dict[str, float] = {}

    for tr in trades:
        prev = cum.get(tr.symbol, 0.0)
        new_total = prev + tr.size
        cum[tr.symbol] = new_total

        # Flag the first crossing event in stream order.
        if prev <= T and new_total > T:
            return (tr.symbol, tr.ts)

    return None

from __future__ import annotations

from typing import Iterable


def max_drawdown(daily_pnl: Iterable[float]) -> float:
    """Compute maximum drawdown on cumulative PnL.

    Let equity_t = sum_{i<=t} pnl_i. Drawdown at t is max_{s<=t} equity_s - equity_t.
    Return max_t drawdown_t as a positive float.

    Time: O(n)
    Space: O(1)
    """
    equity = 0.0
    peak = 0.0
    max_dd = 0.0

    for pnl in daily_pnl:
        equity += pnl
        if equity > peak:
            peak = equity
        else:
            dd = peak - equity
            if dd > max_dd:
                max_dd = dd

    return max_dd

/*
Assumptions
- executions(trade_id, fill_id, account_id, symbol, qty, price, execution_ts, ingest_ts)
- Postgres-compatible SQL
- 'Latest ingested' means greatest ingest_ts for a given (trade_id, fill_id)
*/

WITH params AS (
  SELECT
    (CURRENT_DATE - INTERVAL '29 days')::date AS start_date,
    CURRENT_DATE::date AS end_date
),
-- 1) Dedupe fills to the latest ingested record per (trade_id, fill_id)
dedup_fills AS (
  SELECT
    e.trade_id,
    e.fill_id,
    e.account_id,
    e.qty,
    e.price,
    e.execution_ts,
    e.ingest_ts,
    ROW_NUMBER() OVER (
      PARTITION BY e.trade_id, e.fill_id
      ORDER BY e.ingest_ts DESC
    ) AS rn
  FROM executions e
  JOIN params p
    ON e.execution_ts::date BETWEEN p.start_date AND p.end_date
),
latest_fills AS (
  SELECT
    trade_id,
    fill_id,
    account_id,
    qty,
    price,
    execution_ts
  FROM dedup_fills
  WHERE rn = 1
),
-- 2) Aggregate notional by account and trade date
daily_notional AS (
  SELECT
    account_id,
    execution_ts::date AS trade_date,
    SUM(qty * price) AS traded_notional
  FROM latest_fills
  GROUP BY 1, 2
),
-- 3) Calendar for the last 30 calendar days
calendar AS (
  SELECT generate_series(p.start_date, p.end_date, INTERVAL '1 day')::date AS trade_date
  FROM params p
),
-- 4) Accounts with any activity in the window (scope accounts to active ones)
active_accounts AS (
  SELECT DISTINCT account_id
  FROM latest_fills
)
SELECT
  a.account_id,
  c.trade_date,
  COALESCE(d.traded_notional, 0) AS traded_notional
FROM active_accounts a
CROSS JOIN calendar c
LEFT JOIN daily_notional d
  ON d.account_id = a.account_id
 AND d.trade_date = c.trade_date
ORDER BY a.account_id, c.trade_date;

/*
Assumptions
- positions_eod(portfolio_id, position_date, symbol, shares)
- prices_close(symbol, price_date, close_price)
- Business days are represented by position_date rows (common in IM systems).
- Postgres-compatible SQL.
*/

WITH params AS (
  SELECT
    (CURRENT_DATE - INTERVAL '90 days')::date AS lookback_for_prices, -- extra buffer for as-of
    CURRENT_DATE::date AS asof_end
),
-- 1) Get the last 60 business days from positions (business calendar comes from position rows)
last_60_bd AS (
  SELECT position_date
  FROM (
    SELECT
      DISTINCT p.position_date,
      DENSE_RANK() OVER (ORDER BY p.position_date DESC) AS dr
    FROM positions_eod p
    JOIN params prm
      ON p.position_date <= prm.asof_end
  ) x
  WHERE x.dr <= 60
),
positions_scoped AS (
  SELECT
    p.portfolio_id,
    p.position_date,
    p.symbol,
    p.shares
  FROM positions_eod p
  JOIN last_60_bd d
    ON p.position_date = d.position_date
),
-- 2) As-of join using a lateral subquery to pick the latest close on or before position_date
positions_priced AS (
  SELECT
    ps.portfolio_id,
    ps.position_date,
    ps.symbol,
    ps.shares,
    pc.close_price
  FROM positions_scoped ps
  LEFT JOIN LATERAL (
    SELECT c.close_price
    FROM prices_close c
    JOIN params prm ON TRUE
    WHERE c.symbol = ps.symbol
      AND c.price_date <= ps.position_date
      AND c.price_date >= prm.lookback_for_prices
    ORDER BY c.price_date DESC
    LIMIT 1
  ) pc ON TRUE
)
SELECT
  portfolio_id,
  position_date,
  SUM(shares * close_price) AS market_value
FROM positions_priced
GROUP BY 1, 2
ORDER BY portfolio_id, position_date;

What jumps out isn't any single dominant area. It's that GS spreads weight across six areas with no safe one to skip, yet the case study round (which simulates real Asset Management decisions like sizing an allocation to a new stat-arb strategy) demands you pull from nearly every other area simultaneously. The biggest prep mistake is drilling ML and coding in isolation, then freezing when a case prompt requires you to question a backtest's Sharpe ratio, sketch a validation scheme, and justify the business decision in one coherent answer. From what candidates report, that synthesis under pressure is where preparation breaks down.

Drill GS-style case and modeling questions with financial framing at datainterview.com/questions.

How to Prepare for Goldman Sachs Data Scientist Interviews

Goldman Sachs Asset Management oversees $3.5 trillion in assets under supervision, and its 2026 investment outlook makes clear that alternatives and AI-driven analytics are where the firm is placing its bets. For data scientists, that translates to quantitative strategies for navigating market inefficiencies and building AI applications for automation and customer engagement, not just back-office reporting.

The "why GS" answer that actually works ties your skills to a specific problem the firm has publicly named. GS has forecast that alternative investment demand will outstrip origination supply, a supply-demand imbalance that creates real modeling challenges around allocation and risk. Pair that with the firm's published skepticism about generative AI hype and you can articulate a point of view on where LLMs add value in investment research versus where they don't. That's a far more memorable answer than "I want to apply ML in finance."

Try a Real Interview Question

| trade_date | portfolio_id | pnl  |
|------------|--------------|------|
| 2025-01-02 | PF1          | 100  |
| 2025-01-03 | PF1          | -50  |
| 2025-01-06 | PF1          | 150  |
| 2025-01-07 | PF1          | 0    |
| 2025-01-08 | PF1          | 200  |

WITH base AS (
  SELECT
    trade_date,
    portfolio_id,
    CAST(pnl AS DOUBLE PRECISION) AS pnl
  FROM portfolio_pnl
  WHERE portfolio_id = 'PF1'
), w AS (
  SELECT
    trade_date,
    COUNT(*) OVER (
      ORDER BY trade_date
      ROWS BETWEEN 4 PRECEDING AND CURRENT ROW
    ) AS window_n,
    AVG(pnl) OVER (
      ORDER BY trade_date
      ROWS BETWEEN 4 PRECEDING AND CURRENT ROW
    ) AS pnl_mean,
    SUM(pnl * pnl) OVER (
      ORDER BY trade_date
      ROWS BETWEEN 4 PRECEDING AND CURRENT ROW
    ) AS sum_x2,
    SUM(pnl) OVER (
      ORDER BY trade_date
      ROWS BETWEEN 4 PRECEDING AND CURRENT ROW
    ) AS sum_x
  FROM base
)
SELECT
  trade_date,
  window_n,
  pnl_mean,
  CASE
    WHEN window_n >= 2 THEN
      SQRT( (sum_x2 - (sum_x * sum_x) / window_n) / (window_n - 1) )
    ELSE NULL
  END AS pnl_vol
FROM w
ORDER BY trade_date;

GS data scientists ship production code on an internal stack that includes Scala, Java, and contributions to the open-source Legend platform, so coding rounds test whether you write reviewable, deployable code rather than notebook-style scripts. Expect the interviewer to probe edge cases and ask you to reason about complexity tradeoffs out loud. Drill similar problems on datainterview.com/coding, prioritizing clean Python with proper error handling over speed-optimized one-liners.

Test Your Readiness

Focus on the financial reasoning gaps (Sharpe ratio intuition, VaR interpretation) that separate GS interviews from generic DS loops, then target those weak spots at datainterview.com/questions.