Data Modeling Interview Questions: 16 Real Questions with Answers
Sixteen data modeling questions from real Indian interviews — star schemas, SCD 1/2/3, grain, Kimball vs Inmon, and dbt-era modeling — answered the way strong candidates answer them.
By Durgesh Yadav — Senior Data Engineer @ 7-Eleven · Updated 29 Jul 2026. Preparation guidance, not a hiring guarantee.
What are the most common data modeling interview questions?
Data modeling interviews test star vs snowflake schemas, fact and dimension table types, slowly changing dimensions (SCD 1/2/3), grain declaration, and surrogate keys. Senior rounds add Kimball vs Inmon, conformed dimensions, and why modern columnar warehouses favor wide tables. Expect a whiteboard exercise: model an e-commerce or rides dataset end to end.
Services and GCC rounds open with definitional questions — star vs snowflake, SCD types — then move quickly to a whiteboard: 'model orders for an e-commerce or food-delivery app'. Product-company rounds push tradeoffs instead: grain choices, one-big-table vs star, and late-arriving data.
SCD Type 2 implementation is the single most-asked modeling question
Declare the grain aloud before naming any measure — interviewers listen for it
Whiteboard practice beats memorized definitions: model e-commerce, rides, and payments end to end
Which Kimball vocabulary must you own?
Dimensional modeling has a precise shared language, and interviewers use terminology fluency as a proxy for real project experience. Each term should come with a one-line example from a domain you can defend under follow-up questions.
Dimension types: conformed, degenerate, junk, role-playing, plus SCD 1/2/3
Additive vs semi-additive vs non-additive measures, with a bank-balance example ready
What do interviewers expect in the dbt era?
2026 rounds assume warehouse-native modeling: dbt layering, incremental strategies, tests, and an honest opinion on wide serving tables versus star schemas. Explaining how dbt snapshots implement SCD Type 2 declaratively is a genuine differentiator at both GCCs and product companies.
Layering: staging, intermediate, marts with stg_, int_, fct_, dim_ naming
Incremental models: unique_key, is_incremental(), and lookback windows for late data
dbt tests — unique, not_null, relationships — as your data-quality answer
Real questions from beginner to advanced, each with a concise model answer — practice them, then rehearse live in a mock interview. Every answer is open; collapse any you have already covered.
EasyWhat is the difference between star and snowflake schema?
A star schema puts a central fact table one join away from denormalized dimension tables — dim_product carries category and department as plain columns. A snowflake schema normalizes those dimensions into sub-dimensions (product → category → department), removing redundancy and saving some storage, but adding joins to every query and complicating the BI semantic layer. In modern columnar warehouses storage is cheap and every extra join costs query time and optimizer risk, so star is the default. Snowflaking earns its place for very large dimensions with deep hierarchies owned by separate teams. The trap: arguing snowflake is 'more correct' because it is normalized — a warehouse is optimized for reads, not writes.
EasyWhat is the difference between a fact table and a dimension table?
Fact tables store measurable business events at a declared grain — order lines, payments, page views — as numeric measures plus foreign keys to dimensions; they are long, narrow, and grow continuously, often to billions of rows. Dimension tables store the descriptive context — who, what, where, when — and are wide, comparatively small, and slowly changing. The quick test: you aggregate facts (SUM, COUNT, AVG) and you filter, group, and label by dimensions. The follow-up interviewers probe: some attributes can be either — price is a measure on the fact, but 'price band' is a dimension attribute — and a fact table with no measures at all (a factless fact) is still valid for recording that an event occurred, like student attendance.
EasyWhat is the grain of a fact table and why must it be declared first?
Grain is the precise definition of what one fact row represents — 'one row per order line', not vaguely 'orders'. Kimball's first rule is to declare it before choosing measures or dimensions, because every measure and foreign key must be true at exactly that grain. The classic bug: putting order-level shipping cost on an order-line-grain table, so it double-counts the moment anyone sums it; the fix is allocating it across lines or moving it to an order-grain fact. Mixed grain also breaks joins — a dimension that only applies to some rows signals two facts trying to live in one table. Most real fact-table defects an interviewer will probe are grain violations, which is why the answer should start with 'first, declare the grain'.
EasySurrogate keys vs natural keys — which do you use in a warehouse and why?
Use surrogate keys — meaningless warehouse-generated integers or hashes — as dimension primary keys, and keep the natural business key (employee_id, SKU) as an ordinary attribute. Surrogates insulate the model from source-system key reuse, format changes, and multi-source integration where two systems disagree on customer IDs. They are mandatory for SCD Type 2, where one business key maps to several historical versions, so the natural key alone can no longer be a primary key. They also give you a home for special rows like the 'unknown' member (key -1). Natural keys still matter operationally: they are the lookup handle during ETL and the join column for late-arriving data. The trap: joining facts to dimensions on the natural key in an SCD2 model — it fans out.
EasyExplain 1NF, 2NF, and 3NF in one line each.
1NF: values are atomic with no repeating groups — one value per cell, no comma-separated lists or phone1/phone2/phone3 columns. 2NF: 1NF plus no partial dependency — every non-key attribute depends on the whole composite key, not a subset (in an order_id+product_id table, product_name violates 2NF because it depends only on product_id). 3NF: 2NF plus no transitive dependency — non-key attributes depend on 'the key, the whole key, and nothing but the key', so city → state belongs in its own table. OLTP systems target 3NF to avoid update anomalies; warehouses deliberately denormalize dimensions back toward star schemas because analytical reads outnumber writes. Knowing why you would break the rules is what interviewers listen for.
MediumExplain SCD Types 1, 2, and 3 and when you would use each.
Type 1 overwrites the old value — no history kept, right for corrections like a misspelled name, but it silently rewrites past reports. Type 2 inserts a new row per change with effective_from/effective_to dates, an is_current flag, and a fresh surrogate key — the default whenever history matters, like a customer changing city or segment, because each fact joins to the version that was true at event time. Type 3 adds a 'previous value' column holding exactly one prior state — rare, useful when both views must be queryable side by side, like a one-time sales territory realignment. The follow-up to pre-empt: real dimensions mix types per column — name as Type 1, address as Type 2 — and Type 2 makes the dimension grow, so track only the columns that earn history.
MediumWhat are the three types of fact tables?
Transaction facts record one row per event (an order line) — the most granular and most common, insert-only. Periodic snapshot facts record state at fixed intervals (daily account balance, month-end inventory), needed when the business reports levels rather than deltas; you cannot reconstruct a balance cheaply by replaying every transaction at query time. Accumulating snapshot facts hold one row per process instance with several date columns filled in as the workflow advances — placed, packed, shipped, delivered — making lag and pipeline analysis a simple column subtraction; they are the only fact type routinely updated in place. The interviewer's follow-up: snapshots are usually semi-additive (balances don't sum over time), which shapes how you aggregate them.
MediumExplain additive, semi-additive, and non-additive measures.
Additive measures sum correctly across every dimension — revenue, quantity, cost — and are what fact tables should store wherever possible. Semi-additive measures sum across some dimensions but not time: you can add account balances across branches for one day, but summing a month of daily balances is meaningless — use the average, or the last value per period (typically via a window function picking the latest snapshot). Non-additive measures — ratios, percentages, unit prices — cannot be summed at all; the correct pattern is to store the numerator and denominator as additive facts and compute the ratio at query time, otherwise you get an average of averages. The classic trap interviewers set: 'why is average order value dangerous to store on the fact row?'
MediumWhat are conformed dimensions and why do they matter?
A conformed dimension is one shared, identical version of a dimension — customer, product, date — referenced by multiple fact tables, so 'revenue by customer' from the sales fact and 'tickets by customer' from the support fact agree row for row and can be drilled across in one report. They are the backbone of Kimball's bus architecture: the bus matrix lists business processes as rows and conformed dimensions as columns, and integration happens through those shared columns rather than one giant model. Without conformance every team builds its own dim_customer with its own dedupe rules, dashboards stop agreeing, and trust erodes — the symptom interviewers want you to diagnose. In dbt terms: one canonical dimension model, never per-mart copies.
MediumCompare the Kimball and Inmon approaches.
Inmon is top-down: first build a normalized 3NF enterprise data warehouse as the single integrated source of truth, then spin off dimensional data marts for consumption — more upfront modeling, strong governance, slower first delivery. Kimball is bottom-up: build star-schema marts one business process at a time, integrating them through conformed dimensions on a bus matrix — faster time to value, with integration discipline enforced by conformance rather than a central 3NF layer. In practice the argument is settled by hybrids: most modern dbt/lakehouse stacks keep an Inmon-flavoured cleaned integration layer (staging/intermediate) feeding purely Kimball-style serving marts. Saying 'we do both, at different layers' is the mature answer.
MediumWhat are degenerate, junk, and role-playing dimensions?
A degenerate dimension is a dimension key stored on the fact with no dimension table behind it — invoice_number or order_number: useful for grouping, counting distinct transactions, and drill-through to source, but it has no descriptive attributes of its own. A junk dimension bundles unrelated low-cardinality flags — payment type, is_gift, channel — into one small combination table with a single surrogate key, avoiding half a dozen tiny foreign keys or, worse, flags left on the fact. A role-playing dimension is one physical table used in several roles: dim_date joined as order_date, ship_date, and delivery_date through views or aliases so each role gets distinct column names. All three are grain-preserving tricks to keep fact tables narrow and clean.
MediumStar schema vs one big wide table in BigQuery or Snowflake — what do you recommend?
Columnar engines read only the columns a query touches, so a wide denormalized table is cheap to scan, and removing joins makes BI-tool setup and ad-hoc SQL simpler — which is why one-big-table (OBT) marts are popular as a serving layer. But OBT alone fails in predictable ways: an SCD2 change forces a rewrite of every affected fact row, there is no conformance across marts so metrics drift, and repeated dimension text bloats storage and makes updates expensive. The pragmatic recommendation: model facts and dimensions dimensionally in dbt — that is where history, conformance, and tests live — then materialize purpose-built wide tables on top for each dashboard or team. 'Model dimensional, serve wide' answers both halves of the question.
HardWalk me through implementing SCD Type 2 in a warehouse pipeline.
On each load, compare incoming source rows to the current dimension rows on the natural key, using a hash of the tracked columns to detect real changes cheaply. For changed keys, close the current row — set effective_to = load_date and is_current = false — and insert a new row with a fresh surrogate key, effective_from = load_date, and effective_to open-ended. In SQL this is typically a single MERGE plus insert; in dbt, snapshots with strategy='timestamp' or 'check' do it declaratively. Facts then look up the surrogate key by joining on the natural key where the event date falls between effective_from and effective_to, so each transaction points at the version true at the time. Edge cases to name: same-day multiple changes, deletes in source, and null-safe hash comparison.
HardHow do you handle late-arriving dimensions and early-arriving facts?
An early-arriving fact is a fact that lands before its dimension row — a new customer's first order arrives before the CRM syncs. Don't drop or park it: point it at a placeholder, either the default 'unknown' member (surrogate key -1) or, better, an inferred member created on the fly from the natural key with null attributes; when the real dimension record arrives you update the inferred row in place (a deliberate Type 1 exception). A late-arriving dimension change is harder: the change itself shows up after facts have already been keyed, so you insert an SCD2 version with back-dated effective dates and re-point affected fact rows so history is correct again. Interviewers probe whether your pipeline does this automatically or quietly loses referential integrity.
HardHow do you model a many-to-many relationship, like patients with multiple diagnoses?
The dimensional answer is a bridge table: the fact carries a diagnosis_group_key, and the bridge maps each group_key to its diagnosis_keys with a weighting_factor whose allocations sum to 1 per group. The weighting factor is the point — without it, a claim carrying three diagnoses is counted three times the moment you sum across the bridge, which is the classic double-counting trap. State the trade-off: weighted results are correct in aggregate but individual allocations are a business decision, not a fact. Also name the alternatives — collapsing to a 'primary diagnosis' if the business accepts the loss, or an array column with UNNEST in BigQuery/Snowflake, which trades model purity and BI-tool friendliness for pipeline simplicity.
HardHow do you structure a dbt project, and how do incremental models work?
Standard layering: staging models, one per source table, that rename, cast, and lightly clean (materialized as views); intermediate models for reusable business logic; and marts holding facts, dimensions, and wide serving tables materialized as tables or incrementals. An incremental model processes only new data: materialized='incremental' with a unique_key, guarded by if is_incremental() around a filter like WHERE loaded_at > (SELECT MAX(loaded_at) FROM {{ this }}), compiling to an insert or merge. Pre-empt the failure-mode follow-ups: late-arriving data slips past the filter (add a lookback window), schema drift needs on_schema_change, and a full-refresh must stay affordable. Round out with tests — unique and not_null on keys, relationships from facts to dimensions.
By company
Analytics Engineer interviews that ask these questions
See how this topic shows up in real Analytics Engineer loops — rounds, difficulty and company-specific questions:
Is dimensional modeling still relevant with Snowflake and BigQuery?
Yes — interviewers explicitly test it. Cheap storage changed the economics, but conformance across marts, SCD history, and dashboards that agree with each other are modeling problems that compute cannot solve. The modern answer is dimensional models in dbt with wide serving tables materialized on top.
Which is more asked in Indian interviews — Kimball or Inmon?
Kimball vocabulary dominates practical rounds: grain, conformed dimensions, fact types, and SCDs are all Kimball terms. Inmon appears mainly as a compare-and-contrast question, so know both definitions but be genuinely fluent in Kimball.
How do I practice data modeling without work experience?
Model familiar Indian domains end to end — food delivery, UPI payments, OTT streaming — and write the actual DDL rather than just drawing boxes. Load sample data and build one SCD Type 2 dimension in dbt or plain SQL; that single artifact answers half the modeling round.
Do data analysts need data modeling, or is it only for data engineers?
Analytics engineer and senior analyst roles increasingly get modeling rounds, especially on dbt-heavy teams at product companies and GCCs. Engineers face deeper implementation questions — SCD merges, late-arriving data, incremental loads — while analysts are tested on reading and querying dimensional models correctly.
Next Step
Turn The Guide Into Practice
Use PrepNPlaced tools to turn this learning path into resume proof, targeted practice, and interview-ready explanations.