Warner Bros. Data Analyst Interview Guide

Most candidates prepping for a Warner Bros. Discovery (WBD) data analyst interview focus on aggregation queries and window functions. From what we see in mock interviews, the ones who stand out are those who can walk through how they'd investigate a broken dbt model in Snowflake, trace the root cause, and explain what downstream dashboards it would break. This role is data quality and analytics QA first, BI second.

Warner Bros. Data Analyst Role

This is a data quality and observability role built around WBD's Snowflake + dbt analytics platform. Your primary job is automated validation, testing, and incident response for the data models that power reporting across the company. You'll write SQL and Python-based checks, review dbt PRs, investigate data anomalies, and coordinate fixes with data engineering when something breaks upstream. Success after year one means the models you're responsible for have measurably fewer incidents, stakeholders stop second-guessing the numbers, and you've established testing patterns that other analysts adopt.

A Typical Week

The surprise in this breakdown isn't the analysis time. It's how much of your week goes to infrastructure work and written documentation: auditing a legacy Tableau dashboard that's still running scheduled refreshes against Snowflake for a sunset linear network, or pinning down in Confluence what "addressable impression" actually means before upfront season. At WBD, the analyst who writes the metric definition doc is often doing higher-leverage work than the one building the chart.

Projects & Impact Areas

Max streaming audience analytics is the highest-profile domain, where your data quality checks on subscriber event logs and content performance models feed directly into programming renewal decisions. That work overlaps with ad revenue reporting for linear networks, where you're validating the exact numbers sales teams pitch to advertisers during upfronts. Live sports events like the Olympics create intense spikes: viewership data requests with 24-hour turnarounds where a single bad join in a staging model can cascade into an executive-facing dashboard error.

Skills & What's Expected

Data architecture and pipeline knowledge is the underrated skill here. WBD expects you to understand dbt modeling patterns, catch join fanouts in staging models, and review pipeline PRs, not just write analytical queries. Python matters more than many DA roles because it's central to the automated validation and CI/CD workflows that define this specialization. Business acumen and data visualization score equally high in the skill profile, but they manifest differently than at a typical BI shop: you're translating data quality findings into narratives that a VP of Content Strategy will act on.

Levels & Career Growth

Most external hires land at the mid level, which is the sweet spot where WBD gets someone who can run end-to-end data quality investigations without hand-holding. The jump to Senior hinges less on technical depth and more on whether you're proactively defining new testing standards and influencing metric governance across teams. Lateral moves between WBD's segments (Studios, Networks, Streaming) are common and can be more career-accelerating than waiting for a vertical promotion within one group.

Work Culture

WBD's New York office follows a hybrid policy of roughly three days in-office, with most teams anchoring Tuesday through Thursday for cross-functional collaboration. The pace is reasonable most weeks, but it ratchets up hard around tentpole content launches, upfronts, and live sports windows. The honest tension right now is tooling fragmentation: you'll encounter legacy naming conventions and dashboard standards that haven't been fully reconciled, which is both frustrating and a real opportunity to shape how data quality practices get built.

Warner Bros. Data Analyst Compensation

For the levels shown, comp is structured as base salary plus an annual discretionary bonus, with no stock grants in the data. That said, equity may appear at higher levels or in certain corporate functions, so don't assume it's off the table if you're interviewing for a Lead or specialized role. The bonus component is discretionary, which means it can fluctuate based on company and team performance in ways you can't predict at offer time.

Base salary is your single biggest negotiation lever. Because the bonus is variable and equity isn't a standard part of the package at these levels, locking in a higher base compounds every year in a way nothing else does. Ask your recruiter directly what level the offer maps to and where you sit within that band. If you have competing offers, name them. A sign-on bonus is also worth requesting as a one-time sweetener, since it doesn't require the same ongoing budget approval that a base increase does. The other move most candidates miss: push on level alignment itself, because the jump between bands (say, Analyst II to Senior) dwarfs any within-band negotiation you'll win.

Warner Bros. Data Analyst Interview Process

Budget four weeks from recruiter call to offer, though candidates report communication gaps between rounds that can stretch it to five or six without proactive follow-up. The early rounds aren't freebies: round two is a timed, recorded HireVue-style screen where you can't ask clarifying questions, and the hiring manager conversation in round three probes how you'd define metrics like stream completion rate for a Max content team. Candidates get cut for multiple, overlapping reasons, from botching SQL grain and window functions to giving vague KPI definitions that lack denominator logic or exclusion rules.

The Case Study final round can include cross-functional evaluators from teams like content strategy or ad sales, not just analytics. That means your ability to walk someone from Warner Bros. Discovery's programming side through a retention metric tree, in language they'd actually repeat to their SVP, carries real weight alongside your analytical rigor. If you only prep for technical depth and ignore how you'd narrate a recommendation about, say, Max ad-tier engagement to a non-technical room, you're solving the wrong half of the problem.

Warner Bros. Data Analyst Interview Questions

1WITH daily AS (
2  SELECT
3    CAST(event_date AS DATE) AS ds,
4    product,
5    SUM(impressions) AS impressions
6  FROM fact_ad_impressions
7  WHERE product = 'HBO Max'
8    AND event_date >= DATEADD('day', -30, CURRENT_DATE())
9  GROUP BY 1, 2
10), with_prior AS (
11  SELECT
12    ds,
13    product,
14    impressions,
15    LAG(impressions) OVER (PARTITION BY product ORDER BY ds) AS prior_impressions
16  FROM daily
17)
18SELECT
19  ds,
20  product,
21  impressions,
22  prior_impressions,
23  (impressions - prior_impressions) / NULLIF(prior_impressions, 0) AS pct_change
24FROM with_prior
25WHERE prior_impressions IS NOT NULL
26  AND impressions >= 1000
27  AND prior_impressions >= 1000
28  AND (impressions - prior_impressions) / NULLIF(prior_impressions, 0) < -0.40
29ORDER BY ds;

1WITH source_daily AS (
2  SELECT
3    CAST(event_timestamp AS DATE) AS ds,
4    COUNT(DISTINCT user_id) AS active_viewers_src
5  FROM fact_playback_events
6  WHERE product = 'Discovery+'
7    AND event_timestamp >= DATEADD('day', -60, CURRENT_DATE())
8    AND watch_seconds >= 60
9  GROUP BY 1
10), kpi_daily AS (
11  SELECT
12    ds,
13    metric_value::NUMBER AS active_viewers_kpi
14  FROM kpi_streaming_daily
15  WHERE product = 'Discovery+'
16    AND metric_name = 'active_viewers'
17    AND ds >= DATEADD('day', -60, CURRENT_DATE())
18), reconciled AS (
19  SELECT
20    COALESCE(s.ds, k.ds) AS ds,
21    s.active_viewers_src,
22    k.active_viewers_kpi,
23    (k.active_viewers_kpi - s.active_viewers_src) AS diff,
24    ABS(k.active_viewers_kpi - s.active_viewers_src) / NULLIF(s.active_viewers_src, 0) AS mismatch_rate
25  FROM source_daily s
26  FULL OUTER JOIN kpi_daily k
27    ON s.ds = k.ds
28)
29SELECT
30  ds,
31  active_viewers_src,
32  active_viewers_kpi,
33  diff,
34  mismatch_rate
35FROM reconciled
36WHERE active_viewers_src IS NOT NULL
37  AND active_viewers_kpi IS NOT NULL
38  AND mismatch_rate > 0.005
39ORDER BY ds;

1with raw as (
2  select
3    to_date(event_ts) as event_date,
4    count(*) as raw_cnt
5  from raw.ad_impression_events
6  where to_date(event_ts) between dateadd('day', -2, current_date()) and dateadd('day', -1, current_date())
7    and site = 'wbd_news'
8  group by 1
9),
10final as (
11  select
12    event_date,
13    count(*) as final_cnt
14  from analytics.fct_ad_impressions
15  where event_date between dateadd('day', -2, current_date()) and dateadd('day', -1, current_date())
16    and site = 'wbd_news'
17  group by 1
18),
19dup_keys as (
20  select
21    event_date,
22    impression_id,
23    count(*) as n
24  from analytics.fct_ad_impressions
25  where event_date = dateadd('day', -1, current_date())
26    and site = 'wbd_news'
27  group by 1, 2
28  having count(*) > 1
29)
30select
31  coalesce(r.event_date, f.event_date) as event_date,
32  r.raw_cnt,
33  f.final_cnt,
34  (r.raw_cnt - f.final_cnt) as diff
35from raw r
36full outer join final f
37  on r.event_date = f.event_date
38order by 1;
39
40select * from dup_keys order by n desc;

1from __future__ import annotations
2
3from dataclasses import dataclass
4from datetime import datetime, timedelta, timezone
5from typing import Dict, Any, Optional, List
6
7import pandas as pd
8
9
10class DataQualityError(RuntimeError):
11    """Raised when a data quality check fails."""
12
13
14@dataclass
15class CheckResult:
16    name: str
17    passed: bool
18    details: Dict[str, Any]
19
20
21def _to_utc_timestamp(s: pd.Series) -> pd.Series:
22    """Parse timestamps and force UTC."""
23    ts = pd.to_datetime(s, errors="coerce", utc=True)
24    return ts
25
26
27def validate_max_streaming_events(df: pd.DataFrame) -> List[CheckResult]:
28    """Run a set of deterministic validations for Max streaming events.
29
30    Expected columns:
31      event_id, user_id, event_ts_utc, title_id, play_seconds, country, load_date
32
33    Returns a list of CheckResult. Raises DataQualityError if any check fails.
34    """
35    required_cols = {
36        "event_id",
37        "user_id",
38        "event_ts_utc",
39        "title_id",
40        "play_seconds",
41        "country",
42        "load_date",
43    }
44
45    missing = required_cols - set(df.columns)
46    if missing:
47        raise DataQualityError(f"Missing required columns: {sorted(missing)}")
48
49    # Normalize types
50    df = df.copy()
51    df["event_ts_utc"] = _to_utc_timestamp(df["event_ts_utc"])
52    df["load_date"] = pd.to_datetime(df["load_date"], errors="coerce").dt.date
53    df["play_seconds"] = pd.to_numeric(df["play_seconds"], errors="coerce")
54
55    results: List[CheckResult] = []
56
57    # (a) Duplicate event_id within the same load_date
58    dup_mask = df.duplicated(subset=["load_date", "event_id"], keep=False)
59    dup_df = df.loc[dup_mask, ["load_date", "event_id"]].dropna()
60    dup_examples = (
61        dup_df.drop_duplicates()
62        .head(20)
63        .to_dict(orient="records")
64        if not dup_df.empty
65        else []
66    )
67    results.append(
68        CheckResult(
69            name="duplicate_event_id_within_load_date",
70            passed=dup_df.empty,
71            details={
72                "violation_count": int(dup_df.shape[0]),
73                "distinct_duplicate_keys": int(dup_df.drop_duplicates().shape[0]),
74                "examples": dup_examples,
75            },
76        )
77    )
78
79    # (b) play_seconds negative or above 12 hours
80    max_play = 12 * 60 * 60
81    play_bad_mask = df["play_seconds"].isna() | (df["play_seconds"] < 0) | (df["play_seconds"] > max_play)
82    play_bad_df = df.loc[play_bad_mask, ["event_id", "load_date", "play_seconds"]]
83    results.append(
84        CheckResult(
85            name="play_seconds_range_and_non_null",
86            passed=play_bad_df.empty,
87            details={
88                "violation_count": int(play_bad_df.shape[0]),
89                "examples": play_bad_df.head(20).to_dict(orient="records"),
90                "expected_range_seconds": [0, max_play],
91            },
92        )
93    )
94
95    # (c) event_ts_utc falls outside load_date by more than 1 day
96    # Define load_date window as [load_date - 1 day, load_date + 1 day]
97    # Compare in UTC.
98    load_date_ts = pd.to_datetime(df["load_date"], errors="coerce").dt.tz_localize("UTC")
99    lower = load_date_ts - pd.Timedelta(days=1)
100    upper = load_date_ts + pd.Timedelta(days=1) + pd.Timedelta(days=1)  # inclusive of the date boundary
101    # Note: upper is load_date + 2 days at midnight UTC, so anything beyond +1 day (by date) is flagged.
102
103    ts_bad_mask = df["event_ts_utc"].isna() | (df["event_ts_utc"] < lower) | (df["event_ts_utc"] >= upper)
104    ts_bad_df = df.loc[ts_bad_mask, ["event_id", "load_date", "event_ts_utc"]]
105    results.append(
106        CheckResult(
107            name="event_timestamp_within_load_date_plus_minus_one_day",
108            passed=ts_bad_df.empty,
109            details={
110                "violation_count": int(ts_bad_df.shape[0]),
111                "examples": ts_bad_df.head(20).to_dict(orient="records"),
112            },
113        )
114    )
115
116    failed = [r for r in results if not r.passed]
117    if failed:
118        summary = {r.name: r.details for r in failed}
119        raise DataQualityError(f"Data quality checks failed: {summary}")
120
121    return results
122
123
124if __name__ == "__main__":
125    # Minimal example
126    sample = pd.DataFrame(
127        {
128            "event_id": ["e1", "e1", "e2"],
129            "user_id": ["u1", "u1", "u2"],
130            "event_ts_utc": ["2026-02-25T10:00:00Z", "2026-02-25T10:05:00Z", "2026-02-20T00:00:00Z"],
131            "title_id": ["t1", "t1", "t2"],
132            "play_seconds": [30, 30, -5],
133            "country": ["US", "US", "US"],
134            "load_date": ["2026-02-25", "2026-02-25", "2026-02-25"],
135        }
136    )
137
138    try:
139        validate_max_streaming_events(sample)
140    except DataQualityError as e:
141        print(str(e))
142

1from __future__ import annotations
2
3from dataclasses import dataclass
4from typing import List, Optional
5
6import pandas as pd
7
8
9@dataclass
10class SpikeFlag:
11    metric_date: str
12    brand: str
13    metric: str
14    value: float
15    baseline_mean: float
16    baseline_std: float
17    threshold: float
18    non_null_days: int
19
20
21def detect_brand_spikes(
22    df: pd.DataFrame,
23    metric: str,
24    window_days: int = 28,
25    min_non_null_days: int = 21,
26    sigma: float = 4.0,
27) -> pd.DataFrame:
28    """Flag spikes for a single metric using a rolling baseline per brand.
29
30    df columns: metric_date, brand, sessions, pageviews, ad_impressions
31    Rule: flag if value > mean + sigma * std, computed on the previous window_days.
32    Baseline must have at least min_non_null_days non-null observations.
33
34    Returns a DataFrame of flags.
35    """
36    required = {"metric_date", "brand", metric}
37    missing = required - set(df.columns)
38    if missing:
39        raise ValueError(f"Missing columns: {sorted(missing)}")
40
41    d = df[["metric_date", "brand", metric]].copy()
42    d["metric_date"] = pd.to_datetime(d["metric_date"], errors="coerce")
43    d[metric] = pd.to_numeric(d[metric], errors="coerce")
44
45    # Sort for stable rolling behavior
46    d = d.sort_values(["brand", "metric_date"]).reset_index(drop=True)
47
48    # Rolling baseline should not include the current day, so use shift(1)
49    grp = d.groupby("brand", sort=False)[metric]
50    shifted = grp.shift(1)
51
52    roll_mean = shifted.groupby(d["brand"]).rolling(window_days, min_periods=1).mean().reset_index(level=0, drop=True)
53    roll_std = shifted.groupby(d["brand"]).rolling(window_days, min_periods=1).std(ddof=0).reset_index(level=0, drop=True)
54    roll_n = shifted.groupby(d["brand"]).rolling(window_days, min_periods=1).count().reset_index(level=0, drop=True)
55
56    d["baseline_mean"] = roll_mean
57    d["baseline_std"] = roll_std.fillna(0.0)
58    d["non_null_days"] = roll_n.astype(int)
59    d["threshold"] = d["baseline_mean"] + sigma * d["baseline_std"]
60
61    # Apply min history constraint
62    eligible = d["non_null_days"] >= min_non_null_days
63
64    # Guard: if baseline is zero std and zero mean, threshold equals zero, this can over-flag.
65    # That is acceptable for QA only if the metric should never be zero. Otherwise, tune separately.
66    flagged = eligible & d[metric].notna() & (d[metric] > d["threshold"])
67
68    out = d.loc[flagged, ["metric_date", "brand", metric, "baseline_mean", "baseline_std", "threshold", "non_null_days"]].copy()
69    out = out.rename(columns={metric: "value"})
70
71    # Make output easy to push into Slack or an incident ticket
72    out["metric_date"] = out["metric_date"].dt.strftime("%Y-%m-%d")
73    out["metric"] = metric
74
75    return out.sort_values(["metric_date", "brand"]).reset_index(drop=True)
76
77
78if __name__ == "__main__":
79    sample = pd.DataFrame(
80        {
81            "metric_date": pd.date_range("2026-01-01", periods=40, freq="D").tolist() * 1,
82            "brand": ["WBNews"] * 40,
83            "sessions": [100] * 35 + [1000, 1100, 900, 950, 980],
84            "pageviews": [200] * 40,
85            "ad_impressions": [300] * 40,
86        }
87    )
88    flags = detect_brand_spikes(sample, metric="sessions")
89    print(flags)
90

Three quarters of the question weight centers on finding and fixing broken data, not analyzing clean datasets. That ratio makes sense when you consider WBD is still stitching together legacy Discovery and WarnerMedia pipelines, where a misaligned subscriber definition between Max and Discovery+ can silently corrupt a KPI overnight. The biggest prep trap? Grinding cohort analysis and window functions while neglecting the validation SQL and dbt testing patterns that dominate this loop, specifically for WBD scenarios like reconciling ad impression counts across HBO Max's ad-supported tier and CNN Digital properties.

Rehearse WBD-style KPI definition and data quality scenarios at datainterview.com/questions.

How to Prepare for Warner Bros. Data Analyst Interviews

WBD recently announced it's splitting into two divisions: Global Linear Networks and Streaming & Studios. For data analysts, this structural shift raises the stakes on metric alignment and data governance, since teams across linear TV, Max streaming, and ad sales each carry their own legacy definitions of basic concepts like "viewer" or "engagement."

The company is also pushing hard to position itself as a one-stop shop for advertisers heading into the 2026/2027 upfront marketplace, while investing in tools like DAISY, their internal text-to-SQL platform that lets non-technical stakeholders query data directly. Both bets depend on clean, trustworthy data pipelines, which is exactly where analysts spend their time.

Skip the "I love HBO" answer when asked why WBD. Instead, talk about the specific challenge that excites you: reconciling how a "view" is counted differently on Max's ad-supported tier versus CNN Digital versus a linear TNT Sports broadcast, and why getting that right matters for the advertiser pitch. That framing shows you understand the actual work, not just the brand.

Try a Real Interview Question

1WITH daily_counts AS (
2  SELECT
3    event_date,
4    platform,
5    COUNT(*) AS event_count
6  FROM fact_session_events
7  GROUP BY 1, 2
8)
9SELECT
10  d.event_date,
11  d.platform,
12  d.event_count,
13  e.expected_min_events,
14  CASE WHEN d.event_count < e.expected_min_events THEN 'FAIL' ELSE 'PASS' END AS status
15FROM daily_counts d
16JOIN dim_expected_daily_volume e
17  ON d.platform = e.platform
18ORDER BY d.event_date, d.platform;

WBD's interview process, from what candidates report, leans toward SQL that validates data integrity rather than pure analytical aggregation. Practice writing queries that check for null rates, join fanouts, and row-count mismatches at datainterview.com/coding.

Test Your Readiness

Use datainterview.com/questions to rehearse KPI definition and stakeholder communication questions. At WBD, articulating why you chose a specific metric matters more than how fast you can write the query.