Snap Data Analyst Interview Guide

From hundreds of mock interviews we've run, the single biggest mistake candidates make prepping for Snap's data analyst loop is treating experimentation as one topic among many. Snap probes A/B testing deeply, asking about network interference on Snapchat's social graph, novelty effects on Spotlight, and how to interpret ambiguous results when users influence each other's behavior. If you're going to over-index on one area, make it experimentation.

Snap Data Analyst Role

This isn't a "pull numbers when the PM asks" kind of analyst seat. Snap's data analysts own the full stack from pipeline to presentation: you'll build and maintain your own ETL workflows, run experiment analyses for features like My AI and Spotlight's algorithmic feed, and present findings to product and engineering leads who expect you to have an opinion on what to ship. Success after year one looks like owning a metrics surface end to end (say, Snap Map engagement or ad auction performance), where you've built the pipelines, defined the KPIs, and run experiments that directly influenced a product decision.

A Typical Week

Pipeline ownership eats more of the week than most candidates expect. At Snap specifically, you're responsible for building data quality checks and documentation so that teams consuming Spotlight engagement data or ad auction metrics can actually trust what they're querying. The ad-hoc pulls (DAU trends, revenue anomalies, content moderation escalations) still happen constantly, but they sit on infrastructure you personally keep healthy.

Projects & Impact Areas

Ad revenue work dominates a big slice of the role, with analysts digging into auction mechanics, advertiser ROI measurement, and forecasting tied to DAU fluctuations. On the product side, you'll find yourself analyzing retention curves for Snap Map, measuring whether Spotlight's recommendation algorithm drives session time without cannibalizing Stories, or helping Trust & Safety teams quantify the impact of content moderation policy changes. Some of the most interesting open questions sit at these intersections, where a single experiment touches both user experience and advertiser outcomes simultaneously.

Skills & What's Expected

SQL and Python proficiency won't differentiate you here. What will is your ability to walk into a room, present a finding about My AI engagement or Spotlight retention, and change a VP's mind about a feature launch. The job descriptions rate machine learning as low priority, so don't spend prep time on model building, but the emphasis on business acumen means you're expected to independently frame which metrics matter for a product question rather than waiting for a PM to hand you a measurement plan.

Levels & Career Growth

Job postings reference "3+ years" and "4+ years" experience tiers, suggesting at least two distinct analyst bands. From what candidates report, the blocker to moving up is almost always scope of influence rather than technical depth: senior roles expect you to shape the experimentation roadmap for an entire product surface, not just execute analyses someone else prioritized. The heavy pipeline expectations already baked into the analyst role also make a lateral move into analytics engineering a natural path.

Work Culture

Snap mandated return to office in February 2023 at four days per week, with Santa Monica HQ and Palo Alto as the main hubs, so remote flexibility is minimal. The pace is fast and the data infrastructure evolves frequently, which means your pipelines will break when upstream schemas change, and fixing them is considered your responsibility. That can be energizing or exhausting depending on your tolerance for ambiguity.

Snap Data Analyst Compensation

SNAP has been a volatile stock, and like any publicly traded company offering RSUs, the gap between your grant-date valuation and what you actually vest can be significant. Before signing, ask your recruiter for specifics on the vesting schedule, cliff, and refresh grant policy, because these details shape your real total comp far more than the headline number.

On negotiation: competing offers from other tech companies remain, from what candidates report, the strongest lever for moving equity or sign-on numbers. If you don't have a competing offer in hand, focus your push on whichever comp component the recruiter signals has room, and don't assume you already know which one that is.

Snap Data Analyst Interview Process

Snap's experimentation round trips up more candidates than any other, from what we've seen. The questions go beyond textbook A/B test design into Snapchat-specific complications: how social graph interference on Stories or group chats breaks standard independence assumptions, or how to isolate ad experiment effects when treatment impacts both Snap user engagement and advertiser bid behavior simultaneously.

Prepare for the product sense round to demand Snap-specific fluency. You'll be asked to propose metrics frameworks for surfaces like Spotlight's algorithmic feed or My AI's retention, and interviewers can tell immediately if you're recycling generic engagement frameworks versus reasoning about how Snapchat's ephemeral messaging model changes what "good" looks like. Practice building metric hierarchies for each major Snap surface before your onsite.

Snap Data Analyst Interview Questions

/*
DAU by platform for a single day.
Assumptions:
- events is partitioned by event_date.
- app_open is the canonical open event.
- platform values like 'ios', 'android'.
*/
SELECT
  e.platform,
  COUNT(DISTINCT e.user_id) AS dau
FROM events e
WHERE e.event_date = DATE '2026-01-15'
  AND e.event_name = 'app_open'
  AND e.user_id IS NOT NULL
  AND e.platform IS NOT NULL
GROUP BY e.platform
ORDER BY dau DESC;

/*
D1 retention for a single install cohort date.
Definitions:
- Cohort: users with install_date = 2026-01-01.
- Return event: any app_open on install_date + 1.
Assumptions:
- users table contains one row per user with install_date and install_platform.
- events table contains app_open with event_date.
*/
WITH cohort AS (
  SELECT
    u.user_id,
    u.install_platform
  FROM users u
  WHERE u.install_date = DATE '2026-01-01'
    AND u.user_id IS NOT NULL
    AND u.install_platform IS NOT NULL
),
returns AS (
  SELECT DISTINCT
    e.user_id
  FROM events e
  WHERE e.event_date = DATE '2026-01-02'
    AND e.event_name = 'app_open'
    AND e.user_id IS NOT NULL
)
SELECT
  c.install_platform,
  COUNT(DISTINCT c.user_id) AS cohort_users,
  COUNT(DISTINCT CASE WHEN r.user_id IS NOT NULL THEN c.user_id END) AS d1_returners,
  1.0 * COUNT(DISTINCT CASE WHEN r.user_id IS NOT NULL THEN c.user_id END)
      / NULLIF(COUNT(DISTINCT c.user_id), 0) AS d1_retention_rate
FROM cohort c
LEFT JOIN returns r
  ON r.user_id = c.user_id
GROUP BY c.install_platform

UNION ALL

SELECT
  'ALL' AS install_platform,
  COUNT(DISTINCT c.user_id) AS cohort_users,
  COUNT(DISTINCT CASE WHEN r.user_id IS NOT NULL THEN c.user_id END) AS d1_returners,
  1.0 * COUNT(DISTINCT CASE WHEN r.user_id IS NOT NULL THEN c.user_id END)
      / NULLIF(COUNT(DISTINCT c.user_id), 0) AS d1_retention_rate
FROM cohort c
LEFT JOIN returns r
  ON r.user_id = c.user_id
ORDER BY install_platform;

import pandas as pd
import numpy as np


def compute_7d_retention(events: pd.DataFrame) -> pd.DataFrame:
    """Compute 7-day retention by signup cohort.

    Retention definition:
      For each cohort_date, a user is retained if they have >= 1 app_open in
      [cohort_date + 7 days, cohort_date + 8 days).

    Expected columns: user_id, event_ts (UTC timestamp), event_name, cohort_date.
    """
    df = events.copy()

    # Normalize types
    df["event_ts"] = pd.to_datetime(df["event_ts"], utc=True, errors="coerce")
    # Treat cohort_date as a date boundary at midnight UTC
    df["cohort_date"] = pd.to_datetime(df["cohort_date"], errors="coerce").dt.tz_localize("UTC")

    # Base population, one row per user per cohort
    base = (
        df[["user_id", "cohort_date"]]
        .dropna()
        .drop_duplicates()
    )

    # Filter qualifying events for the retention window
    opens = df[df["event_name"] == "app_open"].dropna(subset=["event_ts", "cohort_date", "user_id"])

    # Compute per-row window boundaries and qualify within [start, end)
    start = opens["cohort_date"] + pd.Timedelta(days=7)
    end = opens["cohort_date"] + pd.Timedelta(days=8)
    qualifies = (opens["event_ts"] >= start) & (opens["event_ts"] < end)

    retained_users = (
        opens.loc[qualifies, ["user_id", "cohort_date"]]
        .drop_duplicates()
        .assign(retained=1)
    )

    out = (
        base.merge(retained_users, on=["user_id", "cohort_date"], how="left")
        .assign(retained=lambda x: x["retained"].fillna(0).astype(int))
        .groupby("cohort_date", as_index=False)
        .agg(n_users=("user_id", "nunique"), retained_users=("retained", "sum"))
    )

    out["retention_7d"] = np.where(out["n_users"] > 0, out["retained_users"] / out["n_users"], np.nan)
    return out.sort_values("cohort_date")

import numpy as np
import pandas as pd


def bootstrap_lift_ci_pvalue(
    df: pd.DataFrame,
    metric_col: str = "minutes_watched_7d",
    variant_col: str = "variant",
    control_label: str = "control",
    treat_label: str = "treat",
    n_boot: int = 20000,
    seed: int = 7,
) -> dict:
    """Bootstrap mean lift, 95% CI, and two-sided p-value.

    Lift is defined as: mean(treat) - mean(control).
    Bootstrap is over users, so df must be one row per user.
    """
    d = df[[variant_col, metric_col]].dropna().copy()

    x_c = d.loc[d[variant_col] == control_label, metric_col].to_numpy(dtype=float)
    x_t = d.loc[d[variant_col] == treat_label, metric_col].to_numpy(dtype=float)

    if len(x_c) < 2 or len(x_t) < 2:
        raise ValueError("Need at least 2 users per variant for bootstrap.")

    rng = np.random.default_rng(seed)

    # Point estimate
    lift_hat = float(x_t.mean() - x_c.mean())

    # Bootstrap samples (resample users with replacement within each arm)
    idx_c = rng.integers(0, len(x_c), size=(n_boot, len(x_c)))
    idx_t = rng.integers(0, len(x_t), size=(n_boot, len(x_t)))

    boot_c = x_c[idx_c].mean(axis=1)
    boot_t = x_t[idx_t].mean(axis=1)
    boot_lift = boot_t - boot_c

    # 95% percentile CI
    ci_low, ci_high = np.quantile(boot_lift, [0.025, 0.975])

    # Two-sided p-value under null Delta = 0 using bootstrap distribution symmetry
    # Compute proportion of bootstrap lifts at least as extreme as observed.
    p_two_sided = float(np.mean(np.abs(boot_lift) >= abs(lift_hat)))

    return {
        "lift_hat": lift_hat,
        "ci_95": (float(ci_low), float(ci_high)),
        "p_value_two_sided": p_two_sided,
        "n_control": int(len(x_c)),
        "n_treat": int(len(x_t)),
        "n_boot": int(n_boot),
    }

What jumps out isn't any single category but how the weight spreads across three distinct technical muscles: designing experiments, building the pipelines that produce metrics, and writing the SQL that queries them. When A/B testing questions land on Snap-specific surfaces like Spotlight's algorithmic feed or Snap Map's location-sharing model, they force you to simultaneously reason about metric strategy (15% of questions) and experiment mechanics, compounding the difficulty in a way pure stats prep won't cover. The prep mistake most candidates make is treating this like a SQL-heavy loop. SQL is only a fifth of the questions, tied with pipelines/ETL, yet it's the skill people default to drilling because it feels most concrete.

Practice Snap-style experimentation and product metrics questions at datainterview.com/questions.

How to Prepare for Snap Data Analyst Interviews

Snap is a company living in two timelines at once. The Specs Inc. spinoff created a standalone AR hardware entity chasing external investment and building multimodal AI-powered Lenses, spatial intelligence APIs, and real-time speech recognition. Meanwhile, the core Snapchat app still generates nearly all of the company's $5.9B in annual revenue, almost entirely from advertising.

The "why Snap" answer most candidates flub focuses on AR vision without confronting the hard analytical puzzle sitting right in front of the company. Snap's Q4 2025 results showed 10% revenue growth alongside a decline in daily active users. A sharper answer: "I want to be on the team figuring out how monetization per user is climbing while the user base shrinks, and whether that's sustainable or a warning sign." That tells your interviewer you've read the earnings and you think like an analyst, not a press release.

Try a Real Interview Question

| experiment_assignments |
|------------------------|
| user_id | exp_id | variant   | assigned_at |
|--------|--------|-----------|-------------|
| 101    | 9001   | control   | 2026-01-01  |
| 102    | 9001   | treatment | 2026-01-01  |
| 103    | 9001   | control   | 2026-01-02  |
| 104    | 9001   | treatment | 2026-01-02  |

| user_daily_metrics |
|--------------------|
| user_id | event_date  | app_open | purchase |
|--------|-------------|----------|----------|
| 101    | 2026-01-03  | 1        | 0        |
| 101    | 2026-01-06  | 1        | 1        |
| 102    | 2026-01-04  | 1        | 1        |
| 103    | 2026-01-05  | 0        | 0        |
| 104    | 2026-01-08  | 1        | 0        |

WITH params AS (
  SELECT 9001 AS exp_id
),
assigned AS (
  SELECT a.user_id, a.exp_id, a.variant, CAST(a.assigned_at AS DATE) AS assigned_date
  FROM experiment_assignments a
  JOIN params p ON a.exp_id = p.exp_id
),
windowed AS (
  SELECT
    s.user_id,
    s.variant,
    s.assigned_date,
    m.event_date,
    m.app_open,
    m.purchase
  FROM assigned s
  LEFT JOIN user_daily_metrics m
    ON m.user_id = s.user_id
   AND CAST(m.event_date AS DATE) BETWEEN s.assigned_date AND (s.assigned_date + INTERVAL '6' DAY)
),
per_user AS (
  SELECT
    user_id,
    variant,
    MAX(CASE WHEN COALESCE(app_open, 0) > 0 THEN 1 ELSE 0 END) AS exposed,
    MAX(CASE WHEN COALESCE(purchase, 0) > 0 THEN 1 ELSE 0 END) AS converted
  FROM windowed
  GROUP BY 1, 2
),
agg AS (
  SELECT
    variant,
    SUM(exposed) AS n_exposed,
    SUM(CASE WHEN exposed = 1 THEN converted ELSE 0 END) AS x_converted,
    CASE WHEN SUM(exposed) = 0 THEN 0.0 ELSE 1.0 * SUM(CASE WHEN exposed = 1 THEN converted ELSE 0 END) / SUM(exposed) END AS p
  FROM per_user
  GROUP BY 1
),
wide AS (
  SELECT
    MAX(CASE WHEN variant = 'control' THEN n_exposed END) AS n_c,
    MAX(CASE WHEN variant = 'treatment' THEN n_exposed END) AS n_t,
    MAX(CASE WHEN variant = 'control' THEN x_converted END) AS x_c,
    MAX(CASE WHEN variant = 'treatment' THEN x_converted END) AS x_t,
    MAX(CASE WHEN variant = 'control' THEN p END) AS p_c,
    MAX(CASE WHEN variant = 'treatment' THEN p END) AS p_t
  FROM agg
),
stats AS (
  SELECT
    n_c,
    n_t,
    x_c,
    x_t,
    p_c,
    p_t,
    (p_t - p_c) AS lift,
    CASE WHEN (n_c + n_t) = 0 THEN NULL ELSE 1.0 * (x_c + x_t) / (n_c + n_t) END AS p_hat,
    CASE
      WHEN n_c = 0 OR n_t = 0 OR (n_c + n_t) = 0 THEN NULL
      ELSE SQRT(
        ( (1.0 * (x_c + x_t) / (n_c + n_t)) * (1 - (1.0 * (x_c + x_t) / (n_c + n_t))) )
        * (1.0 / n_c + 1.0 / n_t)
      )
    END AS se_pooled
  FROM wide
),
final AS (
  SELECT
    n_c,
    n_t,
    x_c,
    x_t,
    p_c,
    p_t,
    lift,
    se_pooled,
    CASE WHEN se_pooled IS NULL OR se_pooled = 0 THEN NULL ELSE lift / se_pooled END AS z_stat,
    CASE
      WHEN se_pooled IS NULL OR se_pooled = 0 THEN NULL
      ELSE 2 * (1 - (0.5 * (1 + ERF(ABS(lift / se_pooled) / SQRT(2)))))
    END AS p_value_two_sided,
    CASE
      WHEN (n_c + n_t) = 0 THEN NULL
      ELSE (ABS( (1.0 * n_t / (n_c + n_t)) - 0.5 ) > 0.01)
    END AS srm_flag
  FROM stats
)
SELECT *
FROM final;

This type of problem reflects how Snap interviews actually work: SQL grounded in product surfaces like Spotlight watch sessions, Snap Map check-ins, or ad impression funnels rather than abstract puzzles. Expect to write queries that tie directly to DAU/MAU definitions or advertiser conversion events specific to Snapchat's ad auction. Sharpen that muscle at datainterview.com/coding, focusing on cohort retention and funnel conversion patterns.

Test Your Readiness

Use datainterview.com/questions to drill the experimentation and causal inference scenarios you'll face, especially ones involving social network interference effects unique to Snapchat's friend graph.