JP Morgan Chase Data Scientist Interview Guide

From hundreds of mock interviews we've run, the single biggest predictor of success at JP Morgan Chase isn't technical depth. It's whether you can reframe a model's precision-recall curve as a dollar figure that a Managing Director in Card Services would repeat in a quarterly business review. Candidates who lead with architecture choices instead of business impact consistently underperform in the later rounds.

JP Morgan Chase Data Scientist Role

You're building and maintaining models that directly affect how JPMC catches fraud and scores risk within its Consumer Banking operation, particularly across Chase's card transaction network. The day-in-life data paints a clear picture: you'll spend time monitoring a transaction fraud classifier's drift metrics in SageMaker, engineering behavioral features in PySpark on EMR, and then translating all of that into findings decks for non-technical VPs. Success after year one means you can point to a measurable business outcome (a false positive reduction, an improved KS/Gini on a credit scorer, or a shipped champion-challenger test on a Chase Mobile risk threshold) that survived a full model governance review with the Model Risk Management team.

A Typical Week

The ratio of communication work to pure coding will surprise anyone coming from a tech company. Stakeholder readouts aren't a Friday afterthought; they're a recurring commitment where you build dollar-impact estimates and defend methodology to Card Services leadership who care about business recommendations, not your hyperparameter grid. The genuine research time baked into the weekly rhythm (prototyping graph neural networks for transaction fraud, reviewing JPMC's internal AI research digest) is unusually generous for a bank this size and keeps the work from feeling purely operational.

Projects & Impact Areas

Fraud detection on Chase's card transactions is the flagship workstream, where you're engineering features like session velocity, merchant category sequences, and geolocation deviation scores from billions of rows in the firm's internal data lake. That work sits alongside credit risk scoring models tied to regulatory stress tests like CCAR, where model outputs carry direct P&L consequences and face actual auditor scrutiny. A growing GenAI practice is also creating new demand, applying LLMs and RAG pipelines through frameworks like LangChain to document processing and internal tooling.

Skills & What's Expected

What's underrated for this role is your ability to write model documentation that satisfies Model Risk Management reviewers under SR 11-7 supervisory expectations, without needing hand-holding from senior teammates. Python and SQL are table stakes, PySpark on EMR is the real workhorse at JPMC's data scale, and the skill profile rates communication just as high as machine learning because every model needs a stakeholder-facing narrative before it ships. Deep learning frameworks like PyTorch and TensorFlow show up in preferred qualifications (especially for teams working on LLMs and NLP), so don't dismiss them, but interpretability constraints mean gradient boosting and logistic regression still carry heavy production workloads on the fraud and risk side.

Levels & Career Growth

The jump that stalls most people is Senior Associate to VP, and it's almost never about technical ability. What separates those levels is owning a model portfolio end-to-end, including governance, stakeholder relationships, and the business case, not just the code. Lateral moves across business lines (Consumer Banking DS to Investment Banking quant analytics, for instance) are genuinely possible at a firm with this many divisions, which is a real perk if you want breadth.

Work Culture

JPMC's culture notes describe a structured hybrid policy with at least three days per week in-office, Tuesdays through Thursdays being the heaviest, at locations like the Manhattan campus or Jersey City. The pace is steady rather than chaotic, but navigating model governance alongside the Model Risk Management team and compliance reviewers adds an intellectual weight that pure tech roles don't have. Hierarchy is real, face time with senior leaders still counts, and the banking floors run noticeably more formal than the tech org's subculture.

JP Morgan Chase Data Scientist Compensation

RSUs at JPMC generally don't start until the VP level, so if you're comparing against a tech offer, you're mostly weighing base salary plus a discretionary annual cash bonus (paid each January, with the possibility of a full payout even if you started mid-year). That bonus is tied to both firm performance and your individual rating, which means real year-to-year variance that no offer letter can guarantee.

Your strongest negotiation levers, from what candidates report, are base salary and the performance bonus target. JPMC's recruiters will ask about competing opportunities without usually requiring written proof, so surface other offers early and let them close the gap across whichever component has the most room. Don't expect a dollar-for-dollar match against a tech package with equity; JPMC's counter will lean on the cash bonus and, in some cases, a signing bonus to bridge the difference.

JP Morgan Chase Data Scientist Interview Process

The most common reason candidates wash out isn't technical weakness. It's failing to connect their data science skills to JPMC's financial context. Candidates who can't explain why they'd pick a specific evaluation metric for a fraud model, or who freeze when asked to scope data requirements for a credit default problem, get flagged across multiple rounds. Strong SQL and stats are necessary but not sufficient when every round (from the case study to the behaviorals) probes whether you can operate inside a regulated, compliance-heavy environment like JPMC's Consumer Banking or Commercial Banking divisions.

The two behavioral rounds carry real veto power, and they aren't redundant. From what candidates report, one tends to be with your prospective team lead and the other with a more senior leader outside the immediate group, meaning a weak showing on either can sink an otherwise strong technical performance. JPMC's internal scheduling across business lines can also stretch the timeline well beyond the typical window, so don't panic if you hit a multi-week gap between rounds.

JP Morgan Chase Data Scientist Interview Questions

WITH base AS (
  SELECT
    t.merchant_id,
    t.txn_id
  FROM card_txn t
  WHERE t.status = 'SETTLED'
    AND t.txn_ts >= (CURRENT_DATE - INTERVAL '90' DAY)
), disputed AS (
  -- Distinct txn_id to avoid double counting if multiple dispute rows exist per transaction
  SELECT DISTINCT
    d.txn_id
  FROM dispute d
  WHERE d.opened_ts >= (CURRENT_DATE - INTERVAL '90' DAY)
), merchant_counts AS (
  SELECT
    b.merchant_id,
    COUNT(DISTINCT b.txn_id) AS settled_txn_cnt,
    COUNT(DISTINCT CASE WHEN dis.txn_id IS NOT NULL THEN b.txn_id END) AS disputed_settled_txn_cnt
  FROM base b
  LEFT JOIN disputed dis
    ON dis.txn_id = b.txn_id
  GROUP BY b.merchant_id
)
SELECT
  merchant_id,
  settled_txn_cnt,
  disputed_settled_txn_cnt,
  (disputed_settled_txn_cnt::DECIMAL(18,6) / NULLIF(settled_txn_cnt, 0)) AS dispute_rate
FROM merchant_counts
WHERE settled_txn_cnt >= 500
ORDER BY dispute_rate DESC, settled_txn_cnt DESC
FETCH FIRST 20 ROWS ONLY;

import pandas as pd
import numpy as np


def top_fraud_loss_days(txns: pd.DataFrame, tz: str = "UTC", top_k: int = 5) -> pd.DataFrame:
    """Build daily fraud metrics and return the top days by fraud dollar loss.

    Parameters
    ----------
    txns : pd.DataFrame
        Columns: account_id, txn_time (tz-aware), amount, is_fraud.
    tz : str
        Target timezone to normalize days (default UTC).
    top_k : int
        Number of days to return.

    Returns
    -------
    pd.DataFrame
        Columns: day, txn_count, total_volume, fraud_count, fraud_rate,
                 fraud_dollar_loss.
    """
    required = {"account_id", "txn_time", "amount", "is_fraud"}
    missing = required - set(txns.columns)
    if missing:
        raise ValueError(f"Missing columns: {sorted(missing)}")

    df = txns.copy()

    # Normalize to a single timezone, then derive the day.
    if not pd.api.types.is_datetime64tz_dtype(df["txn_time"]):
        raise TypeError("txn_time must be timezone-aware (datetime64[ns, tz])")
    df["txn_time"] = df["txn_time"].dt.tz_convert(tz)
    df["day"] = df["txn_time"].dt.floor("D")

    # Ensure numeric and boolean types are consistent.
    df["amount"] = pd.to_numeric(df["amount"], errors="coerce")
    df["is_fraud"] = df["is_fraud"].astype(bool)

    # Fraud loss is the sum of fraudulent amounts.
    df["fraud_amount"] = np.where(df["is_fraud"], df["amount"], 0.0)

    daily = (
        df.groupby("day", as_index=False)
        .agg(
            txn_count=("amount", "size"),
            total_volume=("amount", "sum"),
            fraud_count=("is_fraud", "sum"),
            fraud_dollar_loss=("fraud_amount", "sum"),
        )
    )

    # Guard against divide-by-zero.
    daily["fraud_rate"] = np.where(
        daily["txn_count"] > 0, daily["fraud_count"] / daily["txn_count"], 0.0
    )

    out = daily.sort_values("fraud_dollar_loss", ascending=False).head(top_k)
    return out.reset_index(drop=True)

import pandas as pd
import numpy as np

from sklearn.linear_model import LogisticRegression
from sklearn.metrics import roc_auc_score
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler


def train_ach_return_model(df: pd.DataFrame, split_quantile: float = 0.8, tz: str | None = None) -> dict:
    """Create leakage-safe 30D rolling features and evaluate logistic regression.

    Features (per customer, using only past events):
      - rolling_30d_count
      - rolling_30d_sum

    Evaluation:
      - chronological split by event_time at the given quantile
      - AUC on test

    Returns
    -------
    dict with keys: model, auc, split_time, feature_frame
    """
    required = {"customer_id", "event_time", "amount", "returned_within_5d"}
    missing = required - set(df.columns)
    if missing:
        raise ValueError(f"Missing columns: {sorted(missing)}")

    data = df.copy()
    data["event_time"] = pd.to_datetime(data["event_time"], utc=True, errors="coerce")
    if data["event_time"].isna().any():
        raise ValueError("event_time contains unparseable timestamps")

    if tz is not None:
        # Optional normalization if you need business-day alignment.
        data["event_time"] = data["event_time"].dt.tz_convert(tz)

    data["amount"] = pd.to_numeric(data["amount"], errors="coerce")
    if data["amount"].isna().any():
        raise ValueError("amount contains non-numeric values")

    data["y"] = data["returned_within_5d"].astype(int)

    # Sort within customer by time, then compute rolling windows on shifted values.
    data = data.sort_values(["customer_id", "event_time"]).reset_index(drop=True)

    def add_rolling_features(g: pd.DataFrame) -> pd.DataFrame:
        g = g.copy()
        # Exclude the current event: shift by 1.
        g["amount_prev"] = g["amount"].shift(1)

        # Time-based rolling needs the index to be the timestamp.
        g = g.set_index("event_time")
        g["rolling_30d_count"] = (
            g["amount_prev"].rolling("30D", min_periods=1).count().fillna(0.0)
        )
        g["rolling_30d_sum"] = (
            g["amount_prev"].rolling("30D", min_periods=1).sum().fillna(0.0)
        )
        g = g.reset_index()

        # Replace NaNs for customers with no history.
        g["rolling_30d_count"] = g["rolling_30d_count"].fillna(0.0)
        g["rolling_30d_sum"] = g["rolling_30d_sum"].fillna(0.0)
        return g

    feat = data.groupby("customer_id", group_keys=False).apply(add_rolling_features)

    # Chronological split across the full dataset.
    split_time = feat["event_time"].quantile(split_quantile)
    train = feat[feat["event_time"] <= split_time]
    test = feat[feat["event_time"] > split_time]
    if len(test) == 0 or len(train) == 0:
        raise ValueError("Split produced empty train or test, adjust split_quantile")

    X_cols = ["rolling_30d_count", "rolling_30d_sum"]
    X_train, y_train = train[X_cols], train["y"]
    X_test, y_test = test[X_cols], test["y"]

    model = Pipeline(
        steps=[
            ("scaler", StandardScaler()),
            ("lr", LogisticRegression(max_iter=1000, class_weight="balanced")),
        ]
    )
    model.fit(X_train, y_train)

    # Use predicted probabilities for AUC.
    p_test = model.predict_proba(X_test)[:, 1]
    auc = roc_auc_score(y_test, p_test) if y_test.nunique() > 1 else float("nan")

    return {
        "model": model,
        "auc": auc,
        "split_time": split_time,
        "feature_frame": feat,
    }

What jumps out isn't any single category but how the case study round forces you to chain them together: a fraud detection prompt will start as a domain framing question, pivot into model evaluation when you're asked about threshold selection, then land on causal inference when the interviewer asks how you'd measure the policy's downstream impact on chargebacks. The compounding difficulty between ML evaluation and causal inference catches most candidates off guard because JPMC's interviewers on the payments and risk teams expect you to move fluidly from "how does this model perform?" to "did this model actually cause the outcome we observe?" within the same answer. Candidates who prep each topic in isolation tend to freeze at exactly that handoff.

Practice with finance-contextualized questions at datainterview.com/questions.

How to Prepare for JP Morgan Chase Data Scientist Interviews

JPMC is betting hard on physical reach and AI simultaneously. The firm plans to open more than 160 new branches in over 30 states in 2026, targeting underserved regions where 75% of Americans would be within a reasonable drive of a location. Every new branch generates fresh customer transaction data that feeds fraud detection, credit risk, and personalization models, so the data science surface area is literally expanding with the real estate footprint.

On the digital side, JPMC's emerging technology trends report signals serious investment in GenAI for document processing and internal tooling. If you're asked "why JPMC?", anchor your answer to one of these specific bets. Something like: "Chase is expanding into regions with thin branch coverage, and I want to build the customer acquisition models that make those new locations profitable from day one." That framing, pulled from their 2025 Investor Day materials, beats vague enthusiasm about "the scale of financial services" every time.

Try a Real Interview Question

| transaction_id | merchant_id | user_id | txn_ts     | amount_usd | status  |
|----------------|-------------|---------|------------|------------|---------|
| t1             | m1          | u1      | 2024-01-05 | 120.00     | SETTLED |
| t2             | m1          | u2      | 2024-01-20 | 80.00      | SETTLED |
| t3             | m2          | u3      | 2024-01-25 | 50.00      | DECLINED |
| t4             | m2          | u4      | 2024-02-02 | 200.00     | SETTLED |
| t5             | m2          | u5      | 2024-02-15 | 75.00      | SETTLED |

| chargeback_id | transaction_id | cb_ts      | cb_reason |
|--------------|-----------------|------------|-----------|
| c1           | t2              | 2024-02-10 | FRAUD     |
| c2           | t4              | 2024-02-20 | DISPUTE   |
| c3           | t4              | 2024-02-25 | DUPLICATE |
| c4           | t99             | 2024-02-01 | FRAUD     |

WITH settled AS (
  SELECT
    t.transaction_id,
    t.merchant_id,
    DATE_TRUNC('month', t.txn_ts) AS month_start
  FROM transactions t
  WHERE t.status = 'SETTLED'
),
settled_monthly AS (
  SELECT
    month_start,
    merchant_id,
    COUNT(*) AS settled_txn_count
  FROM settled
  GROUP BY 1, 2
),
chargebacks_dedup AS (
  SELECT DISTINCT
    s.transaction_id,
    s.merchant_id,
    s.month_start
  FROM chargebacks cb
  JOIN settled s
    ON cb.transaction_id = s.transaction_id
),
chargebacks_monthly AS (
  SELECT
    month_start,
    merchant_id,
    COUNT(*) AS chargeback_count
  FROM chargebacks_dedup
  GROUP BY 1, 2
)
SELECT
  TO_CHAR(sm.month_start, 'YYYY-MM') AS month,
  sm.merchant_id,
  sm.settled_txn_count,
  COALESCE(cm.chargeback_count, 0) AS chargeback_count,
  COALESCE(cm.chargeback_count, 0)::DECIMAL / sm.settled_txn_count AS chargeback_rate
FROM settled_monthly sm
LEFT JOIN chargebacks_monthly cm
  ON sm.month_start = cm.month_start
 AND sm.merchant_id = cm.merchant_id
WHERE sm.settled_txn_count >= 2
ORDER BY sm.month_start, chargeback_rate DESC, sm.merchant_id;

From what candidates report, JPMC's coding questions lean applied and contextual, often framed around transaction data or risk scenarios rather than pure algorithmic puzzles. Practicing problems with that flavor builds the right muscle memory. You'll find more finance-contextualized coding problems at datainterview.com/coding.

Build Your Finance Translation Layer

You probably already understand precision-recall tradeoffs. The question is whether you can explain why a 2% false positive rate in fraud detection costs Chase millions in blocked legitimate transactions and customer attrition, while a looser threshold invites regulatory scrutiny. That's the kind of reframing JPMC's applied rounds reward: not renaming concepts, but grounding them in real P&L and compliance consequences.

JPMC operates under a formal "How We Do Business" framework that shapes how models get built and governed. When you discuss model choices, weave in awareness of explainability requirements and model risk documentation as first-class deliverables, not afterthoughts. Candidates who treat governance as a constraint they'd tolerate rather than a design input they'd embrace tend to land poorly.

Prepare Distinct Behavioral Stories

JPMC weighs culture fit and conduct risk heavily enough to dedicate significant interview time to behavioral assessment. You'll want at least five or six STAR-format stories covering distinct themes: navigating compliance constraints on a technical decision, influencing a skeptical senior stakeholder with data, handling ambiguity when data was incomplete, and deliberately trading model performance for explainability.

If you've never worked in a regulated industry, pull from any experience where external rules shaped your technical choices (GDPR, HIPAA, internal security policies all count). Have a genuine self-critique ready for each story, because "I wouldn't change anything" reads as low self-awareness in a culture that takes conduct risk seriously.

Test Your Readiness

See where your gaps are and close them with realistic practice at datainterview.com/questions.