Master data engineering and AI like a big tech engineer

OpenAI

Amazon

Netflix

Tesla

Salesforce

Robinhood

Microsoft

Real Time Formula 1 Analytics

Big Bag Data

Chess.com Analytics

Trading Strategy for Crypto Currency - Analytics Engineering Capstone Submission

BetFlow - Real Time Sports Betting App

Showcase of student projects

Capstone Projects

Book a discovery call with Zach

Discovery call

Our students have gone on to work at companies like Meta, Airbnb and Amazon. As well as achieve 100% raises!

Fast Track Your Career

Immediate free cloud access to Databricks, AWS, Snowflake, Astronomer, and more!

Free Cloud Access with tons of hands on exercises

Weekly Guest Speaker Sessions

Why Choose DataExpert.io Academy?

Anthropic

Databricks

Discord

Snowflake

GitHub

A themed six-round mock interview simulating a real Netflix Data Engineer loop. Covers SQL analytics on viewing behavior, data pipeline architecture for streaming events, dimensional modeling for the content catalog, behavioral questions around Netflix's Freedom & Responsibility culture, and a Python DSA problem built around recommendation data structures.

Netflix Data Engineer Interview

Netflix Senior Data Engineer Resume Fit

Netflix tracks every viewing session in a table called `viewing_sessions`:

viewing_sessions (
    session_id BIGINT PRIMARY KEY,
    user_id BIGINT,
    title_id BIGINT,
    country_code VARCHAR(2),
    genre VARCHAR(50),
    watch_duration_minutes INT,
    started_at TIMESTAMP
  )

Write a SQL query that returns the top 3 most-watched genres (by total watch minutes) per country for the last 30 days. Include: country_code, genre, total_watch_minutes, and rank_within_country.

Handle ties by including all genres that tie for 3rd place.

**Expected strong answer includes:** Window function (DENSE_RANK or RANK partitioned by country_code), date filter using started_at, clear CTE structure, correct tie-handling semantics.

Top 3 Most-Watched Genres per Country — Netflix

Using the same viewing_sessions table, a "binge streak" is defined as 3 or more consecutive days where a user watched at least 2 hours total.

Write a SQL query that returns each user's longest binge streak in the last 90 days: user_id, streak_start_date, streak_end_date, streak_days, total_minutes_watched_during_streak.

Output should be one row per user (their longest streak only). Users with no qualifying streak should not appear.

**Expected strong answer includes:** Gaps-and-islands technique, daily aggregation CTE, consecutive-day grouping using ROW_NUMBER difference trick, proper date arithmetic.

Detecting Binge-Watch Streaks — Netflix

Star schema with clear fact_viewing_sessions at session grain, conformed dimensions (dim_title, dim_date, dim_user, dim_device, dim_geography), SCD2 tracking columns (valid_from/valid_to), bridge table for multi-valued genres, clear grain statement.

Netflix Content Catalog Dimensional Model

fact_viewing_session

dim_title

dim_user

dim_device

dim_geography

dim_date

Kafka/Kinesis for ingestion, schema registry for evolution, Flink/Spark Structured Streaming for enrichment, Lambda/Kappa architecture considerations, S3 + Iceberg for the batch layer, a fast OLAP store (Druid/Pinot/ClickHouse) for real-time dashboards, dead-letter queues for late arrivals, idempotent replay strategy for backfill.

Real-Time Viewing Event Pipeline — Netflix

Specific technical scenario (not vague), evidence of direct communication, shows intellectual humility, demonstrates the Netflix value of "disagree then commit," acknowledges trade-offs.

Netflix Culture: Radical Candor Conflict

Concrete system (not abstract), demonstrates initiative (they drove it, not assigned), shows awareness of why complexity accumulated (not blame), evidence of stakeholder management, quantified improvement (latency, incidents reduced, onboarding time), demonstrates the Netflix principle of "highly aligned, loosely coupled.

Netflix Culture: Simplifying a Complex System

Netflix's trending algorithm needs to detect titles whose hourly view count 
exceeds 2x their trailing 24-hour average at any point.

You are given a stream of events as a list of tuples:
  events: List[Tuple[int, str]]  # (unix_timestamp, title_id)

Implement:

def find_trending_titles(events: List[Tuple[int, str]], window_hours: int = 24, spike_multiplier: float = 2.0) -> List[Tuple[str, int]]:
    
Returns a list of (title_id, spike_timestamp) for every title that spiked above spike_multiplier * its trailing window_hours average  at any hourly boundary.
    
Events are NOT guaranteed to be sorted by timestamp. A title can appear multiple times if it spikes more than once. Return the list sorted by title_id, then by spike_timestamp (both ascending).
    

Constraints:
- Events list can contain up to 10 million entries
- Timestamps span up to 30 days
- Optimize for O(n log n) or better
- Use only standard library (collections, heapq, bisect allowed)

Sliding Window: Trending Titles Detector — Netflix

Modified Dijkstra's algorithm with genre-filtering at node expansion, correct distance = 1 - similarity transformation, heap-based priority queue, handles disconnected graph, O((V + E) log V) complexity.

Netflix Data Engineer Interview

In order. Round N+1 unlocks when Round N passes.