Snap Data Engineer Interview Guide

From hundreds of mock interviews, one pattern keeps showing up with Snap data engineering candidates: they prep heavily for coding and SQL, then get blindsided by how much the interview cares about stakeholder communication and pipeline ownership. Snap runs two separate rounds that touch behavioral skills, and the technical rounds themselves probe whether you understand why a pipeline matters to the Ads team, not just how to build it.

Snap Data Engineer Role

You're building and owning the pipelines that power Snap's ad revenue engine, which accounts for the vast majority of the company's roughly $5.9B in annual revenue. Event-level data from 400M+ DAU flows through orchestrated DAGs into warehouse tables consumed by auction models, attribution logic, and advertiser-facing dashboards. Success after year one means you've shipped production pipelines that the Ads Measurement team actually trusts, you've driven adoption of your datasets across multiple consumer teams, and you've started shaping how Snap's data platform evolves rather than just writing jobs on top of it.

A Typical Week

Infrastructure and maintenance work takes a bigger slice of the week than most candidates expect. SLA reviews, on-call triage, data reconciliation against billing systems, and runbook updates compete for time against the greenfield pipeline building that drew you to the role. The cross-functional syncs with teams like Ads Measurement and Spotlight recommendations are where you'll build the business context that separates a good pipeline engineer from a great one.

Projects & Impact Areas

Ad revenue pipelines sit at the center of gravity: eCPM attribution, multi-touch event tracking, and the tables that finance pulls for Monday reporting. But the work growing fastest involves newer product surfaces. Snapchat+ subscription analytics needs its own event pipelines, AR engagement telemetry from Spectacles introduces a data profile that looks nothing like mobile app clickstreams (think sensor data, sparse event schemas, session durations measured in seconds), and the internal data platform itself is an active project area where your Airflow and warehouse contributions shape what every other data team can build.

Skills & What's Expected

Pipeline architecture is the skill tested at expert depth, and it's where underprep hurts most. Warehouse partitioning strategies, slowly changing dimension handling, orchestration tradeoffs, schema evolution for event data: this is the core of both the role and the interview. Software engineering in Python, Java, or Scala matters but plays a supporting role. Business acumen is the underrated dimension. Snap expects you to articulate why a freshness breach on the Stories table matters to the content team, not just fix the stuck upstream consumer. ML knowledge is rated medium: you won't be training models, but you should understand how to serve clean feature stores and training data to the teams that do, and basic ML concepts may come up in interviews.

Levels & Career Growth

Most external hires land at Level 4 (mid) or Level 5 (senior), and the gap between them isn't years of experience. Level 4 owns individual pipelines end-to-end; Level 5 owns cross-team platform decisions, writes design docs that set partitioning and SLA standards for an entire domain, and mentors others. From what candidates and current engineers report, the promotion blocker from 4 to 5 is scope of influence: you can write flawless DAGs for years and plateau if you're not shaping how other teams consume and build on your work.

Work Culture

Snap mandated four days in-office starting February 2023, with Tuesday through Friday at the Santa Monica HQ and Monday as the flexible remote day. Not a remote-friendly company. The pace is fast but surprisingly sustainable: most engineers are offline by 6 PM, and weekend work only happens during on-call rotations. Snap's engineering culture leans toward rebuilding systems rather than patching them indefinitely, so you should be comfortable proposing that a legacy Java ETL job gets rewritten in Python rather than duct-taped for another quarter.

Snap Data Engineer Compensation

Snap's RSUs vest monthly over three years with no cliff, calculated on a 30-day trailing average close price rather than your grant-date price. Your sign-on bonus is also equity-based, front-loaded with a chunk vesting in six months and the rest over three years. Snap doesn't do traditional yearly refresh grants that stack, so your equity income actually shrinks over time unless you land a promotion or retention grant.

Recruiters will often tell you the offer is non-negotiable. Don't take that at face value. Base salary is genuinely the hardest component to move, but the sign-on bonus and (at senior levels) the initial RSU grant size are where candidates find real flexibility.

Snap Data Engineer Interview Process

Weak SQL skills are the most frequently cited rejection reason, according to candidate reports. But it's not just query fluency that trips people up. The SQL & Data Modeling round asks you to make warehouse-level design decisions (star vs. snowflake tradeoffs, partitioning choices, SCD handling), and candidates who only prepped window functions and CTEs find themselves underprepared for that architectural conversation.

The final round looks behavioral on paper, but the description from interviewers leans heavily technical: expect to walk through a past data engineering project in detail, defend your design choices, and even debug or optimize code on the spot. That means you're really facing two rounds with very different evaluation criteria back to back. Candidates who treat both as standard STAR-method sessions tend to underwhelm on the second, where engineering judgment and system ownership matter more than storytelling polish.

Snap Data Engineer Interview Questions

1/* BigQuery Standard SQL */
2WITH latest_per_payment AS (
3  SELECT
4    payment_id,
5    user_id,
6    amount,
7    status,
8    processed_at,
9    updated_at,
10    ROW_NUMBER() OVER (
11      PARTITION BY payment_id
12      ORDER BY updated_at DESC, processed_at DESC
13    ) AS rn
14  FROM `snap_fintech.snap_payments`
15), deduped AS (
16  SELECT
17    payment_id,
18    user_id,
19    amount,
20    status,
21    processed_at
22  FROM latest_per_payment
23  WHERE rn = 1
24)
25SELECT
26  DATE(processed_at) AS processed_date,
27  SUM(CASE WHEN status = 'SUCCESS' THEN amount ELSE 0 END) AS successful_revenue,
28  COUNT(DISTINCT CASE WHEN status = 'SUCCESS' THEN user_id END) AS paying_users
29FROM deduped
30GROUP BY processed_date
31ORDER BY processed_date;

1from collections import defaultdict
2from typing import Dict, Iterable, List, Tuple
3
4# Type: (user_id, event_time_ms, amount_cents)
5Event = Tuple[str, int, int]
6
7
8def max_10min_spend_by_user(events: Iterable[Event], window_ms: int = 10 * 60 * 1000) -> Dict[str, int]:
9    """Return {user_id: max sum(amount_cents) in any time window of length window_ms}.
10
11    Assumptions:
12      - Events can arrive out of order.
13      - Window is inclusive on the right, and left boundary is (t - window_ms).
14        Concretely, for a right endpoint time r, we keep events with time >= r - window_ms.
15      - amount_cents can be any integer, but typical pipelines expect non-negative.
16    """
17    per_user: Dict[str, List[Tuple[int, int]]] = defaultdict(list)
18    for user_id, t_ms, amt in events:
19        per_user[user_id].append((t_ms, amt))
20
21    result: Dict[str, int] = {}
22
23    for user_id, rows in per_user.items():
24        # Sort by event time to enable a two-pointer sliding window.
25        rows.sort(key=lambda x: x[0])
26
27        left = 0
28        running_sum = 0
29        best = 0
30
31        for right in range(len(rows)):
32            t_r, amt_r = rows[right]
33            running_sum += amt_r
34
35            # Shrink from the left until the window satisfies time constraint.
36            min_allowed = t_r - window_ms
37            while left <= right and rows[left][0] < min_allowed:
38                running_sum -= rows[left][1]
39                left += 1
40
41            if running_sum > best:
42                best = running_sum
43
44        result[user_id] = best
45
46    return result
47
48
49if __name__ == "__main__":
50    sample = [
51        ("u1", 1_000, 100),
52        ("u1", 2_000, 200),
53        ("u1", 700_000, 500),  # outside 10 min from earlier ones
54        ("u2", 3_000, 50),
55        ("u2", 4_000, 75),
56        ("u2", 5_000, 25),
57    ]
58    print(max_10min_spend_by_user(sample))
59

1import heapq
2from collections import defaultdict
3from typing import Dict, Iterable, List, Tuple
4
5# Type: (viewer_id, story_id, view_time_ms)
6View = Tuple[str, str, int]
7
8
9def top_k_stories_by_unique_viewers(
10    views: Iterable[View],
11    now_ms: int,
12    k: int,
13    window_ms: int = 24 * 60 * 60 * 1000,
14) -> List[Tuple[str, int]]:
15    """Return list of (story_id, unique_viewer_count) sorted by count desc, story_id asc.
16
17    Deduplication is per (viewer_id, story_id) within the 24 hour window.
18    """
19    if k <= 0:
20        return []
21
22    cutoff = now_ms - window_ms
23
24    seen_pairs = set()  # (viewer_id, story_id)
25    counts: Dict[str, int] = defaultdict(int)
26
27    for viewer_id, story_id, t_ms in views:
28        if t_ms < cutoff or t_ms > now_ms:
29            continue
30        key = (viewer_id, story_id)
31        if key in seen_pairs:
32            continue
33        seen_pairs.add(key)
34        counts[story_id] += 1
35
36    # Keep a min-heap of size k for top-k selection.
37    # Tie-breaker: story_id ascending in final output.
38    heap: List[Tuple[int, str]] = []  # (count, story_id)
39    for story_id, cnt in counts.items():
40        item = (cnt, story_id)
41        if len(heap) < k:
42            heapq.heappush(heap, item)
43        else:
44            # Replace if strictly better, or same count but lexicographically smaller story_id.
45            if item[0] > heap[0][0] or (item[0] == heap[0][0] and item[1] < heap[0][1]):
46                heapq.heapreplace(heap, item)
47
48    # heap is smallest-first, convert to required order.
49    out = [(story_id, cnt) for cnt, story_id in heap]
50    out.sort(key=lambda x: (-x[1], x[0]))
51    return out
52
53
54if __name__ == "__main__":
55    now = 2_000_000
56    views = [
57        ("v1", "s1", now - 1_000),
58        ("v1", "s1", now - 900),   # duplicate pair
59        ("v2", "s1", now - 800),
60        ("v1", "s2", now - 700),
61        ("v3", "s2", now - 600),
62        ("v4", "s3", now - 500),
63    ]
64    print(top_k_stories_by_unique_viewers(views, now_ms=now, k=2))
65

The distribution above tells a clear story: Snap wants pipeline architects, not algorithm grinders. Pipelines and system design together create compounding difficulty because a prompt like "design the batch-plus-streaming flow for Snap Ads net revenue by advertiser" forces you to simultaneously reason about orchestration, failure recovery, SLA tradeoffs, and cost-aware partitioning in BigQuery. The single biggest prep mistake? Drilling coding problems while glossing over data modeling, where Snap interviewers will press you on grain choices and SCD strategies for real scenarios like finance reconciliation against Snap Pay transactions, and a weak answer there bleeds into your system design and SQL scores too.

Sharpen your answers with Snap-specific practice problems and walkthroughs at datainterview.com/questions.

How to Prepare for Snap Data Engineer Interviews

Snap reported $5.9 billion in revenue with 10.2% year-over-year growth, and the company is actively working to [diversify beyond advertising into premium subscriptions](https://www.dcfmodeling.com/blogs/vision/snap-mission-vision?srsltid=AfmBOopmIn5eMfbxMn5NRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXlwNRJSUjicdES3gDXl