Pinterest Data Scientist Interview Guide

Pinterest leans unusually hard on statistics and causal inference in its DS interview loop. From what candidates report, the weight on experiment design and quasi-experimental methods far exceeds what you'd face at peer companies hiring for ads and recommendation roles. If your prep plan is heavy on coding and light on difference-in-differences, you're aiming at the wrong target.

Pinterest Data Scientist Role

This isn't a "build models in a notebook and hand them off" seat. Pinterest data scientists own the full arc from framing the business question (should we gate the shoppable Pins ranking rollout by market?) through experiment design, causal analysis, and the recommendation to ship or hold. You're embedded with product and engineering partners on teams like Shopping, Homefeed Ranking, or Ads Delivery, and your output is decisions, not dashboards.

A Typical Week

The writing component is the thing that surprises people. Pinterest has a strong design doc and experiment readout culture, so DSs produce written artifacts that travel without them: findings templates, deployment plans, methodology write-ups. The infrastructure work is small in proportion but urgent when it hits. Debugging a broken Airflow DAG because the Ads Serving team changed a logging schema isn't glamorous, but if you can't do it, your downstream models go stale.

Projects & Impact Areas

Ads performance optimization is the revenue engine, where you might build an advertiser LTV forecasting model using Spark SQL features on spend velocity and seasonal patterns, then evaluate whether temporal fusion transformers beat the current Prophet + gradient boosting ensemble. Marketing science sits adjacent, focused on geo-experiments to prove that an advertiser's Pinterest spend actually caused incremental conversions rather than just capturing existing demand. Woven through both is Pinterest's unique visual discovery problem: bridging the gap between someone saving a "mid-century modern living room" Pin and actually buying the couch through a shoppable Pin conversion funnel.

Skills & What's Expected

The most underrated skill on the scorecard is software engineering. Candidates assume this is a "SQL and stats" seat, but you'll write production-quality Python, build Hive tables, maintain Airflow DAGs, and do code reviews on teammates' causal inference notebooks. GenAI isn't tested and isn't required per current job descriptions, so if you spend prep time on LLM fine-tuning instead of robust standard errors, you're optimizing for the wrong interview. Business acumen and data visualization are both rated expert, which makes sense for a company whose product is inherently visual and whose DS team presents ship/no-ship recommendations directly to senior leadership.

Levels & Career Growth

L6 (Staff) postings are tied to specific strategic domains like ads performance, forecasting, or marketing science, and they explicitly require owning a measurement or modeling roadmap end-to-end. That's the real L5-to-L6 gate: not building a better model, but deciding which models the team should build next and convincing leadership why. L7 (Principal) roles are rare, report to the Director of Data Science, and carry company-wide scope.

Work Culture

Pinterest's hybrid policy requires one day per week in the office, and from what SF-based DS teams report, most cluster their in-office days Tuesday through Thursday for cross-functional syncs. The pace is deliberate compared to hypergrowth startups. There's genuine respect for deep work blocks, and from what candidates and employees describe, most people log off by 6 PM, though crunch happens around quarterly planning and big launches.

Pinterest Data Scientist Compensation

The front-loaded vesting schedule is the single biggest thing to understand before evaluating an offer. Your year-one TC will look noticeably higher than what you'll actually earn in subsequent years, because a disproportionate chunk of equity lands early. Before you compare Pinterest's number against another offer, calculate the annualized average across the full grant period so you're comparing apples to apples.

The negotiation data from the source is clear: base salary and RSU grant size are both movable levers. Equity makes up an increasingly large share of total comp as you move up the ladder (check the widget), so pushing on grant size tends to yield more than fighting over base. The biggest lever most candidates overlook? Simply asking the recruiter to walk through the exact vesting schedule and confirm whether the numbers on your offer letter reflect annualized or first-year comp. That one question reframes the entire conversation and prevents you from anchoring on an inflated number.

Pinterest Data Scientist Interview Process

The full loop takes about four weeks from recruiter call to offer decision. Insufficient depth in statistics and experimentation design is among the most common rejection reasons, and it catches people off guard because Pinterest's Stats & Probability round covers power analysis, A/B test design, and interpreting results under real constraints like confounding variables and selection bias on a visual discovery platform.

The Behavioral round carries the least weight in the loop, but from what candidates report, a poor showing there still functions as a veto. Pinterest screens hard for cross-functional collaboration skills, which makes sense given that DSs on the ads performance and marketing science teams spend half their week presenting to PMs and engineers who don't share their statistical vocabulary.

Pinterest Data Scientist Interview Questions

WITH filtered AS (
  SELECT
    CAST(date_trunc('day', event_ts) AS date) AS ds,
    user_id,
    request_id,
    pin_id,
    event_ts
  FROM impression_events
  WHERE surface = 'homefeed'
    AND COALESCE(is_bot, FALSE) = FALSE
    AND user_id IS NOT NULL
    AND request_id IS NOT NULL
    AND pin_id IS NOT NULL
),
-- Deduplicate retries: keep the first observed event per (user_id, request_id, pin_id)
-- so each request contributes at most one impression for that pin.
base AS (
  SELECT
    ds,
    user_id,
    request_id,
    pin_id,
    ROW_NUMBER() OVER (
      PARTITION BY ds, user_id, request_id, pin_id
      ORDER BY event_ts ASC
    ) AS rn
  FROM filtered
)
SELECT
  ds,
  user_id,
  COUNT(*) AS unique_impressions
FROM base
WHERE rn = 1
GROUP BY 1, 2
ORDER BY 1, 2;

WITH imps AS (
  SELECT
    CAST(date_trunc('day', event_ts) AS date) AS ds,
    event_ts AS imp_ts,
    user_id,
    pin_id,
    request_id,
    experiment_id,
    variant
  FROM impression_events
  WHERE experiment_id IS NOT NULL
    AND variant IS NOT NULL
    AND user_id IS NOT NULL
    AND request_id IS NOT NULL
    AND pin_id IS NOT NULL
),
click_candidates AS (
  SELECT
    i.ds,
    i.experiment_id,
    i.variant,
    i.user_id,
    i.pin_id,
    i.request_id,
    i.imp_ts,
    c.event_ts AS click_ts,
    ROW_NUMBER() OVER (
      PARTITION BY i.user_id, i.request_id, i.pin_id, i.imp_ts
      ORDER BY c.event_ts ASC
    ) AS click_rank
  FROM imps i
  LEFT JOIN click_events c
    ON c.user_id = i.user_id
   AND c.request_id = i.request_id
   AND c.pin_id = i.pin_id
   AND c.event_ts >= i.imp_ts
   AND c.event_ts < i.imp_ts + INTERVAL '10' MINUTE
),
-- One impression contributes at most one click, take the earliest click in the window.
impression_level AS (
  SELECT
    ds,
    experiment_id,
    variant,
    1 AS impression,
    CASE
      WHEN click_rank = 1 AND click_ts IS NOT NULL THEN 1
      ELSE 0
    END AS attributed_click
  FROM click_candidates
)
SELECT
  ds,
  experiment_id,
  variant,
  SUM(attributed_click) AS clicks,
  SUM(impression) AS impressions,
  CAST(SUM(attributed_click) AS double) / NULLIF(SUM(impression), 0) AS ctr
FROM impression_level
GROUP BY 1, 2, 3
ORDER BY 1, 2, 3;

from __future__ import annotations

from dataclasses import dataclass
from datetime import datetime, timezone
from typing import Dict, Iterable, List, Set, Tuple


Event = Tuple[int, int, str]  # (user_id, ts_seconds, event_type)


def _utc_date(ts_seconds: int) -> str:
    """Return YYYY-MM-DD in UTC for a unix timestamp in seconds."""
    return datetime.fromtimestamp(ts_seconds, tz=timezone.utc).date().isoformat()


def distinct_users_with_click_after_impression_same_day(
    events: Iterable[Event], window_seconds: int = 300
) -> int:
    """Count distinct (user, day) where a click occurs within window after an impression.

    Each (user, day) is counted at most once. Only impressions and clicks matter.
    """
    # Group by (user_id, day)
    grouped: Dict[Tuple[int, str], List[Tuple[int, str]]] = {}
    for user_id, ts, etype in events:
        if etype not in ("impression", "click"):
            continue
        key = (user_id, _utc_date(ts))
        grouped.setdefault(key, []).append((ts, etype))

    qualifying_user_days: Set[Tuple[int, str]] = set()

    for key, evs in grouped.items():
        # Sort by time, then type for determinism (type ordering does not affect correctness)
        evs.sort(key=lambda x: (x[0], x[1]))

        impression_times: List[int] = []
        click_times: List[int] = []
        for ts, etype in evs:
            if etype == "impression":
                impression_times.append(ts)
            else:
                click_times.append(ts)

        # Two pointers: for each impression, find first click after it and check window
        j = 0  # pointer into click_times
        for imp_ts in impression_times:
            while j < len(click_times) and click_times[j] < imp_ts:
                j += 1
            if j < len(click_times) and click_times[j] <= imp_ts + window_seconds:
                qualifying_user_days.add(key)
                break  # count user-day once

    return len(qualifying_user_days)


if __name__ == "__main__":
    sample = [
        (1, 1704067200, "impression"),  # 2024-01-01 00:00:00 UTC
        (1, 1704067400, "click"),       # +200s
        (1, 1704153601, "click"),       # next day, should not count for day 1
        (2, 1704067200, "impression"),
        (2, 1704067801, "click"),       # +601s, outside 300s
        (3, 1704067200, "click"),       # click without impression
    ]
    print(distinct_users_with_click_after_impression_same_day(sample, 300))  # expected 1

from __future__ import annotations

from collections import defaultdict, deque
from typing import Deque, Dict, Iterable, List, Optional, Tuple


Row = Tuple[str, str, int, int]  # (day, variant, impressions, clicks), day as ISO YYYY-MM-DD


def max_7day_rolling_ctr(rows: Iterable[Row], window_days: int = 7) -> Dict[str, Tuple[float, str]]:
    """Compute max rolling CTR per variant using ratio of sums over a fixed-size day window.

    Assumptions:
      - Input can be unsorted.
      - There is at most one row per (day, variant). Missing days are allowed and treated as 0.
      - Day strings are sortable as ISO dates.

    Returns:
      dict: variant -> (max_ctr, window_end_day)
    """
    # Build per-variant map day -> (impr, clicks)
    per_variant: Dict[str, Dict[str, Tuple[int, int]]] = defaultdict(dict)
    all_days_set = set()
    for day, variant, impressions, clicks in rows:
        per_variant[variant][day] = (impressions, clicks)
        all_days_set.add(day)

    if not all_days_set:
        return {}

    all_days = sorted(all_days_set)

    results: Dict[str, Tuple[float, str]] = {}

    for variant, day_map in per_variant.items():
        window: Deque[Tuple[int, int]] = deque()  # list of (impr, clicks) for the last N days in all_days order
        sum_impr = 0
        sum_clicks = 0
        best_ctr = float("-inf")
        best_end_day: Optional[str] = None

        for day in all_days:
            impr, clk = day_map.get(day, (0, 0))
            window.append((impr, clk))
            sum_impr += impr
            sum_clicks += clk

            if len(window) > window_days:
                old_impr, old_clk = window.popleft()
                sum_impr -= old_impr
                sum_clicks -= old_clk

            # Define CTR as 0 when sum_impr is 0 to avoid division by zero.
            ctr = (sum_clicks / sum_impr) if sum_impr > 0 else 0.0
            if ctr > best_ctr:
                best_ctr = ctr
                best_end_day = day

        # If variant existed, best_end_day must be set.
        results[variant] = (best_ctr if best_ctr != float("-inf") else 0.0, best_end_day or all_days[-1])

    return results


if __name__ == "__main__":
    data = [
        ("2024-01-01", "control", 100, 10),
        ("2024-01-02", "control", 200, 30),
        ("2024-01-03", "control", 0, 0),
        ("2024-01-01", "treat", 150, 15),
        ("2024-01-02", "treat", 150, 45),
    ]
    print(max_7day_rolling_ctr(data))

Pinterest's loop is built around a core bet: the DS who can design a clean experiment on Homefeed ranking and then defend its causal assumptions to a skeptical ads PM is more valuable than one who can optimize a model's AUC. That bet shows up in how the heaviest question areas compound on each other. Stats questions might ask you to handle zero-inflated saves distributions, and then causal inference questions assume you've already internalized that messiness while layering on identification challenges specific to Pinterest's marketplace (advertiser-side pacing, Trust and Safety policy changes, two-sided creator-consumer dynamics). If your prep plan allocates time proportional to what you'd expect from a coding-heavy loop, you'll walk in underprepared for the rounds that carry the most weight.

Practice stats, causal inference, and product sense questions calibrated to Pinterest-style interviews at datainterview.com/questions.

How to Prepare for Pinterest Data Scientist Interviews

Pinterest is chasing social commerce hard, trying to close the loop between "I love that couch" and "I just bought that couch." Revenue reached $4.2 billion with 14.3% year-over-year growth, and the company is pouring resources into GenAI for content understanding while keeping DS work anchored in experimentation and measurement.

Active job postings for Staff Data Scientist roles in ads performance, forecasting, and marketing science all center on the same tension: Pinterest users carry some of the highest commercial intent in social media, yet revenue per user still trails Meta and Google by a wide margin. Scan the Pinterest Engineering blog for recent posts on experimentation infrastructure and ads ranking before your loop. Those posts reveal the internal vocabulary and tradeoffs you'll want to reference in your answers.

The "why Pinterest" answer that falls flat is the consumer one. "I love using Pinterest for recipes" tells the interviewer nothing about your understanding of the business. What lands is framing your interest around that monetization gap: you want to work on the causal inference and measurement problems that help Pinterest convert high-intent discovery into advertiser ROI without degrading the browsing experience.

Try a Real Interview Question

| ab_assignments |         |         |
|----------------|---------|---------|
| user_id        | exp_id  | variant |
|----------------|---------|---------|
| 101            | exp_42  | control |
| 102            | exp_42  | treat   |
| 103            | exp_42  | treat   |
| 104            | exp_42  | control |

| user_daily_metrics |            |                 |
|-------------------|------------|-----------------|
| user_id           | ds         | outbound_clicks |
|-------------------|------------|-----------------|
| 101               | 2026-01-01 | 2               |
| 101               | 2026-01-08 | 3               |
| 102               | 2026-01-01 | 1               |
| 102               | 2026-01-08 | 4               |
| 103               | 2026-01-01 | 0               |

WITH params AS (
  SELECT
    'exp_42' AS exp_id,
    DATE '2026-01-08' AS exp_start,
    DATE '2026-01-10' AS exp_end,
    DATE '2026-01-01' AS pre_start,
    DATE '2026-01-07' AS pre_end
),
assigned AS (
  SELECT a.user_id, a.variant
  FROM ab_assignments a
  JOIN params p ON a.exp_id = p.exp_id
),
pre_x AS (
  SELECT
    a.user_id,
    COALESCE(SUM(m.outbound_clicks), 0) AS x
  FROM assigned a
  CROSS JOIN params p
  LEFT JOIN user_daily_metrics m
    ON m.user_id = a.user_id
   AND m.ds BETWEEN p.pre_start AND p.pre_end
  GROUP BY 1
),
exp_y_total AS (
  SELECT
    a.user_id,
    COALESCE(SUM(m.outbound_clicks), 0) AS y
  FROM assigned a
  CROSS JOIN params p
  LEFT JOIN user_daily_metrics m
    ON m.user_id = a.user_id
   AND m.ds BETWEEN p.exp_start AND p.exp_end
  GROUP BY 1
),
stats AS (
  SELECT
    AVG(px.x) AS x_bar,
    AVG(ey.y) AS y_bar,
    AVG(CAST(px.x AS DOUBLE) * CAST(ey.y AS DOUBLE)) AS exy,
    AVG(CAST(px.x AS DOUBLE) * CAST(px.x AS DOUBLE)) AS ex2
  FROM pre_x px
  JOIN exp_y_total ey ON ey.user_id = px.user_id
),
theta AS (
  SELECT
    x_bar,
    (exy - x_bar * y_bar) / NULLIF(ex2 - x_bar * x_bar, 0.0) AS theta
  FROM stats
),
daily_y AS (
  SELECT
    a.user_id,
    a.variant,
    m.ds AS ds,
    SUM(m.outbound_clicks) AS y_day
  FROM assigned a
  JOIN params p ON 1 = 1
  JOIN user_daily_metrics m
    ON m.user_id = a.user_id
   AND m.ds BETWEEN p.exp_start AND p.exp_end
  GROUP BY 1, 2, 3
),
daily_adjusted AS (
  SELECT
    dy.ds,
    dy.variant,
    (CAST(dy.y_day AS DOUBLE) - t.theta * (CAST(px.x AS DOUBLE) - t.x_bar)) AS y_adj
  FROM daily_y dy
  JOIN pre_x px ON px.user_id = dy.user_id
  CROSS JOIN theta t
)
SELECT
  ds AS date,
  MAX(CASE WHEN variant IN ('control','treat') THEN (SELECT theta FROM theta) END) AS theta,
  AVG(CASE WHEN variant = 'treat' THEN y_adj END) AS avg_y_treat_adj,
  AVG(CASE WHEN variant = 'control' THEN y_adj END) AS avg_y_ctrl_adj,
  AVG(CASE WHEN variant = 'treat' THEN y_adj END) - AVG(CASE WHEN variant = 'control' THEN y_adj END) AS lift_adj
FROM daily_adjusted
GROUP BY 1
ORDER BY 1;

Pinterest's coding round, from what candidates report, focuses on data manipulation and algorithmic thinking over user-item relationships rather than pure computer science puzzles. You'll want fluency in clean, readable Python that handles messy real-world data. Build that muscle at datainterview.com/coding, where problems are structured around the kinds of pandas and algorithm work that show up in DS loops.

Test Your Readiness

Stats and causal inference carry outsized weight in Pinterest's loop compared to coding or ML. Pressure-test those areas with timed questions at datainterview.com/questions before the real thing.