Cruise Data Scientist Interview Guide

From hundreds of mock interviews, one pattern stands out with Cruise candidates: they prep like it's a pure modeling role and get blindsided by how much pipeline and infrastructure work the job demands. Cruise rates software engineering, data architecture, and ML all as "high," and the interview loop tests all three with equal seriousness.

Cruise Data Scientist Role

You're joining a team that builds models and measurement systems for operations, demand forecasting, and customer analytics across Cruise's business. The tech stack centers on Databricks and Spark for distributed data processing, Azure ML for compute and deployment, and MLflow for experiment tracking and model lineage. Success after year one looks like owning a model end-to-end, from feature engineering through production monitoring, and having it adopted by cross-functional partners in operations or finance.

A Typical Week

The thing that catches people off guard isn't the modeling. It's how much of your week goes to activities that don't feel like "data science": writing stakeholder decks, grooming Jira backlogs, patching upstream data issues before they poison a training set. If you're coming from a role where an engineer productionized your work, expect an adjustment period.

Projects & Impact Areas

Demand forecasting and pricing optimization are core workstreams, feeding directly into revenue and fleet utilization decisions. Those prediction problems sit alongside segmentation and cohort analysis for understanding customer behavior and informing geographic or operational expansion. Data quality and pipeline reliability tie everything together, because models built on enterprise sources (ERP, logistics platforms, external signals) break when schemas drift or upstream joins go stale.

Skills & What's Expected

Software engineering is the most underrated skill for this role. The widget shows it rated "high," same as ML and statistics, but candidates consistently under-prepare for it. Cruise expects production-quality Python with unit tests, Git workflows, and reproducibility standards. GenAI knowledge is rated only "medium," so don't burn prep time on LLM architectures. Classical ML, time-series forecasting, and strong experimental design will serve you far better here.

Levels & Career Growth

The jump to L6 (Staff) is where people stall, because it requires cross-team influence and setting measurement standards that other pods adopt, not just building better models. Cruise's post-2023 restructuring made the org leaner, which cuts both ways: broader ownership and faster visibility for those who stay, but less certainty about long-term team stability. Ask your hiring manager directly about headcount plans for the next 12 months.

Work Culture

The culture_notes in Cruise's own materials describe a hybrid setup with a strong pull toward in-office days, particularly for cross-functional collaboration. Working on safety-adjacent systems creates a more rigorous review culture than you'd find at a typical e-commerce or ad-tech DS team: code reviews are thorough, validation expectations are high, and documentation isn't optional. Worth asking your recruiter about current in-office expectations, since the physical footprint has shifted post-restructuring.

Cruise Data Scientist Compensation

The stock component in Cruise offers is the line item you understand least before asking. The widget shows annual stock figures by level, but the underlying instrument (RSUs, options, phantom equity, or something else) isn't publicly documented. Neither is the vesting schedule, cliff structure, or refresh grant cadence. Before you evaluate any offer, ask your recruiter to spell out exactly what form the equity takes and how it vests, then get those details confirmed in the offer letter.

Negotiation at Cruise comes down to knowing which levers move. The offer notes suggest level, base salary, sign-on bonus, and equity refresh are where you have room, while bonus targets are tied to level and rarely flex. If the equity instrument carries uncertainty you're not comfortable with, ask to shift value toward a larger sign-on or higher base instead.

Cruise Data Scientist Interview Process

Four weeks is the typical timeline from recruiter call to offer. The most common rejection pattern is shallow problem framing: candidates jump into a query or model without first clarifying the decision at stake, the metric definitions, or the safety guardrails that constrain the answer space. At Cruise, where an analytical misstep can ripple into vehicle behavior decisions, skipping the scoping step lands harder than an unfinished solution.

The standalone Statistics & Probability round catches people off guard. Most DS loops at other companies fold stats questions into a case study or ML discussion, but Cruise dedicates a full 60 minutes to probability, experimental design, and causal reasoning tied to AV scenarios like rare-event detection and geo-based experimentation where rider-level randomization isn't feasible. "Statistics without judgment" shows up repeatedly as a rejection reason, so if your prep plan splits time evenly across rounds, shift more toward stats.

Cruise Data Scientist Interview Questions

1WITH active_bookings AS (
2  -- Keep the booking grain clean: one row per active booking on a voyage
3  SELECT
4    b.booking_id,
5    b.voyage_id
6  FROM bookings b
7  WHERE b.status <> 'CANCELLED'
8),
9bookings_per_voyage AS (
10  SELECT
11    ab.voyage_id,
12    COUNT(*) AS active_bookings
13  FROM active_bookings ab
14  GROUP BY ab.voyage_id
15),
16excursion_bookings AS (
17  -- Reduce purchases to the booking-excursion grain to avoid duplicates
18  SELECT DISTINCT
19    ab.voyage_id,
20    ep.excursion_id,
21    ab.booking_id
22  FROM excursion_purchases ep
23  JOIN active_bookings ab
24    ON ab.booking_id = ep.booking_id
25  WHERE ep.purchase_status = 'PURCHASED'
26),
27excursion_attach AS (
28  SELECT
29    eb.voyage_id,
30    eb.excursion_id,
31    COUNT(*) AS bookings_with_excursion
32  FROM excursion_bookings eb
33  GROUP BY eb.voyage_id, eb.excursion_id
34),
35scored AS (
36  SELECT
37    ea.voyage_id,
38    ea.excursion_id,
39    ea.bookings_with_excursion,
40    bpv.active_bookings,
41    (ea.bookings_with_excursion * 1.0) / NULLIF(bpv.active_bookings, 0) AS attach_rate,
42    ROW_NUMBER() OVER (
43      PARTITION BY ea.voyage_id
44      ORDER BY (ea.bookings_with_excursion * 1.0) / NULLIF(bpv.active_bookings, 0) DESC,
45               ea.excursion_id ASC
46    ) AS rn
47  FROM excursion_attach ea
48  JOIN bookings_per_voyage bpv
49    ON bpv.voyage_id = ea.voyage_id
50)
51SELECT
52  voyage_id,
53  excursion_id,
54  attach_rate,
55  bookings_with_excursion,
56  active_bookings
57FROM scored
58WHERE rn <= 3
59ORDER BY voyage_id, rn;

1import pandas as pd
2import numpy as np
3
4
5def daily_city_ride_metrics(df: pd.DataFrame) -> pd.DataFrame:
6    """Compute daily, per-city operational metrics from ride request logs.
7
8    Expected columns:
9      - request_id: unique id
10      - city: str
11      - requested_at: timestamp-like
12      - pickup_at: timestamp-like, null if not picked up
13      - canceled_at: timestamp-like, null if not canceled
14      - status: e.g., 'completed', 'canceled', 'no_show', etc.
15
16    Returns a DataFrame with columns:
17      - date
18      - city
19      - request_count
20      - completed_count
21      - cancel_rate
22      - p90_wait_seconds (completed rides only)
23    """
24
25    required = {"request_id", "city", "requested_at", "pickup_at", "canceled_at", "status"}
26    missing = required - set(df.columns)
27    if missing:
28        raise ValueError(f"Missing required columns: {sorted(missing)}")
29
30    x = df.copy()
31
32    # Parse timestamps defensively.
33    for col in ["requested_at", "pickup_at", "canceled_at"]:
34        x[col] = pd.to_datetime(x[col], errors="coerce", utc=True)
35
36    # Define the daily grain on request time to avoid post-treatment leakage.
37    x["date"] = x["requested_at"].dt.floor("D")
38
39    # Base counts.
40    grp = ["date", "city"]
41    out = x.groupby(grp, dropna=False).agg(
42        request_count=("request_id", "nunique"),
43        completed_count=("status", lambda s: (s == "completed").sum()),
44        canceled_count=("status", lambda s: (s == "canceled").sum()),
45    )
46
47    # Cancel rate over all requests.
48    out["cancel_rate"] = np.where(out["request_count"] > 0, out["canceled_count"] / out["request_count"], np.nan)
49
50    # Wait time for completed rides only. Require pickup_at and requested_at.
51    completed = x.loc[(x["status"] == "completed") & x["pickup_at"].notna() & x["requested_at"].notna(), grp + ["pickup_at", "requested_at"]].copy()
52    completed["wait_seconds"] = (completed["pickup_at"] - completed["requested_at"]).dt.total_seconds()
53
54    # Guard against negative waits from clock skew or bad ingestion.
55    completed.loc[completed["wait_seconds"] < 0, "wait_seconds"] = np.nan
56
57    p90 = (
58        completed.groupby(grp)["wait_seconds"]
59        .quantile(0.9, interpolation="linear")
60        .rename("p90_wait_seconds")
61        .to_frame()
62    )
63
64    out = out.join(p90, how="left")
65
66    # Clean final columns.
67    out = out.reset_index()
68    out = out.drop(columns=["canceled_count"])
69
70    return out
71

1import pandas as pd
2import numpy as np
3
4from sklearn.compose import ColumnTransformer
5from sklearn.pipeline import Pipeline
6from sklearn.preprocessing import OneHotEncoder
7from sklearn.impute import SimpleImputer
8from sklearn.metrics import roc_auc_score
9from sklearn.linear_model import LogisticRegression
10
11
12def build_cancel_training_set(df: pd.DataFrame) -> pd.DataFrame:
13    """Build one-row-per-request supervised dataset for cancel-in-10-min prediction.
14
15    Assumptions for this simplified interview dataset:
16      - Each row is a request.
17      - status is final outcome and includes 'canceled' or 'completed'.
18      - If a separate cancel timestamp exists, you should use it, but it is not provided here.
19
20    Label definition (approximation):
21      - cancel_in_10m = 1 if status == 'canceled' AND (canceled_at - requested_at) <= 10 minutes.
22      - If canceled_at is absent, fallback is to label all 'canceled' as 1 (explicitly called out).
23
24    Returns df with engineered columns: request_week, cancel_in_10m.
25    """
26    x = df.copy()
27
28    # Parse requested_at.
29    x["requested_at"] = pd.to_datetime(x["requested_at"], errors="coerce", utc=True)
30    x = x.loc[x["requested_at"].notna()].copy()
31
32    # If canceled_at exists, use it for a proper 10-min label.
33    if "canceled_at" in x.columns:
34        x["canceled_at"] = pd.to_datetime(x["canceled_at"], errors="coerce", utc=True)
35        dt_min = (x["canceled_at"] - x["requested_at"]).dt.total_seconds() / 60.0
36        x["cancel_in_10m"] = ((x["status"] == "canceled") & (dt_min <= 10)).astype(int)
37    else:
38        # Fallback when only final status exists.
39        x["cancel_in_10m"] = (x["status"] == "canceled").astype(int)
40
41    # Week bucket for time split. Use week starting Monday.
42    x["request_week"] = x["requested_at"].dt.to_period("W-MON").astype(str)
43
44    return x
45
46
47def time_based_week_split_auc(df: pd.DataFrame) -> dict:
48    """Train on earlier weeks, validate on the last week, report AUC."""
49
50    x = build_cancel_training_set(df)
51
52    feature_cols = ["city", "surge_multiplier", "price_quote"]
53    target_col = "cancel_in_10m"
54
55    # Keep only needed columns.
56    x = x[["request_week"] + feature_cols + [target_col]].copy()
57
58    # Determine last week as validation.
59    weeks = sorted(x["request_week"].unique())
60    if len(weeks) < 2:
61        raise ValueError("Need at least 2 weeks of data for a time-based split.")
62
63    val_week = weeks[-1]
64    train = x.loc[x["request_week"] != val_week].copy()
65    val = x.loc[x["request_week"] == val_week].copy()
66
67    # Basic preprocessing.
68    cat_cols = ["city"]
69    num_cols = ["surge_multiplier", "price_quote"]
70
71    pre = ColumnTransformer(
72        transformers=[
73            (
74                "cat",
75                Pipeline(
76                    steps=[
77                        ("impute", SimpleImputer(strategy="most_frequent")),
78                        ("ohe", OneHotEncoder(handle_unknown="ignore")),
79                    ]
80                ),
81                cat_cols,
82            ),
83            (
84                "num",
85                Pipeline(steps=[("impute", SimpleImputer(strategy="median"))]),
86                num_cols,
87            ),
88        ],
89        remainder="drop",
90    )
91
92    model = LogisticRegression(max_iter=200, n_jobs=None)
93
94    clf = Pipeline(steps=[("pre", pre), ("model", model)])
95
96    X_train, y_train = train[feature_cols], train[target_col]
97    X_val, y_val = val[feature_cols], val[target_col]
98
99    clf.fit(X_train, y_train)
100
101    # Predict proba for AUC.
102    p_val = clf.predict_proba(X_val)[:, 1]
103
104    # AUC is undefined if y has one class, handle explicitly.
105    if y_val.nunique() < 2:
106        auc = np.nan
107    else:
108        auc = roc_auc_score(y_val, p_val)
109
110    return {
111        "val_week": val_week,
112        "n_train": int(len(train)),
113        "n_val": int(len(val)),
114        "auc": float(auc) if auc == auc else None,
115    }
116

Applied ML and Stats & Experimentation together form the heaviest slice, but the compounding difficulty comes from how they overlap at Cruise: you'll propose a forecasting model for ride demand across SF zones, then immediately need to design a geo-based experiment to validate it when rider-level randomization isn't feasible. The biggest prep mistake is treating Data Pipelines & Data Quality as an afterthought, because Cruise's Terra platform and petabyte-scale sensor ingestion mean interviewers will probe schema evolution and late-arriving event handling alongside your modeling answers, not in isolation.

Practice questions across all six areas at datainterview.com/questions.

How to Prepare for Cruise Data Scientist Interviews

Cruise is GM's autonomous vehicle subsidiary, and everything a data scientist touches here ties back to one question: is the car safe enough to carry a passenger? Their in-house Spark-based platform, Terra, ingests petabytes of sensor and ride telemetry, so pipeline fluency isn't optional. You'll spend real hours on schema evolution and data quality, not just modeling.

Most candidates answer "why Cruise?" with some version of "self-driving cars are the future." That's forgettable. Show instead that you grasp the constraint that separates this role from every other DS job: a model error here isn't a bad recommendation, it's a safety incident. Connect Cruise's emphasis on people and safety culture to a concrete example of how you've handled high-consequence decisions, or explain specifically how your validation process would change when the cost of a false negative is a collision. After subleasing SoMa office space in 2024, the physical footprint shrank, so ask your recruiter about current in-office expectations before your first screen.

Try a Real Interview Question

1WITH baseline AS (
2  SELECT
3    p.promo_id,
4    p.sailing_id,
5    p.start_date,
6    p.end_date,
7    AVG(CAST(b.bookings AS DECIMAL(18,6))) AS baseline_mean_daily_bookings
8  FROM promos p
9  JOIN daily_bookings b
10    ON b.sailing_id = p.sailing_id
11   AND b.booking_date >= p.start_date - INTERVAL '7' DAY
12   AND b.booking_date < p.start_date
13  GROUP BY
14    p.promo_id,
15    p.sailing_id,
16    p.start_date,
17    p.end_date
18),
19promo_period AS (
20  SELECT
21    p.promo_id,
22    p.sailing_id,
23    p.start_date,
24    p.end_date,
25    SUM(CAST(b.bookings AS DECIMAL(18,6))) AS promo_total_bookings,
26    COUNT(*) AS promo_days
27  FROM promos p
28  JOIN daily_bookings b
29    ON b.sailing_id = p.sailing_id
30   AND b.booking_date >= p.start_date
31   AND b.booking_date <= p.end_date
32  GROUP BY
33    p.promo_id,
34    p.sailing_id,
35    p.start_date,
36    p.end_date
37)
38SELECT
39  pp.sailing_id,
40  pp.promo_id,
41  pp.start_date,
42  pp.end_date,
43  ROUND(bl.baseline_mean_daily_bookings, 3) AS baseline_mean_daily_bookings,
44  pp.promo_days,
45  pp.promo_total_bookings,
46  ROUND(pp.promo_total_bookings - bl.baseline_mean_daily_bookings * pp.promo_days, 3) AS uplift_bookings
47FROM promo_period pp
48JOIN baseline bl
49  ON bl.promo_id = pp.promo_id
50ORDER BY pp.sailing_id, pp.promo_id;

Cruise's coding round, from what candidates report, leans toward end-to-end data workflows in pandas and scikit-learn rather than pure algorithm puzzles. Expect to load messy data, engineer features, and evaluate a model in a single notebook. Build that muscle at datainterview.com/coding by practicing full modeling pipelines, not isolated functions.

Test Your Readiness

Sharpen your weakest topic area, particularly the probability and experimental design questions that catch people off guard, at datainterview.com/questions.