Data Engineering Interview Questions: Data Warehousing
Reviewed by Mark Dickie · Last updated
4 questions on this page you can answer and see marked on the spot. Go to the first one
A data warehouse is a centralized store of integrated, historical data organized for analysis and reporting rather than transaction processing. For a data engineering interview, you should be ready to explain dimensional modeling (star and snowflake schemas), slowly changing dimensions (SCD Types 1–3), the difference between ETL and ELT, and how warehouse architectures like Kimball and Inmon compare. Interviewers also test your grasp of fact vs. dimension tables, grain definition, and when a warehouse fits versus when a data lake or lakehouse is the better choice.
Below is a quick map of the core concepts that come up most often in data warehousing interview rounds.
| Concept | What interviewers ask |
|---|---|
| Dimensional modeling | Star vs. snowflake, fact vs. dimension tables, conformed dimensions |
| Slowly changing dimensions | SCD Type 1, 2, and 3 behavior and when to use each |
| ETL vs. ELT | Where transformation happens, and why modern warehouses shift to ELT |
| Warehouse architectures | Kimball (bottom-up) vs. Inmon (top-down) and their trade-offs |
| Grain | Defining the lowest level of detail in a fact table and why it matters |
What does a data warehousing interview typically test?
- Your ability to design a star schema for a given business process — pick the grain, identify measures and dimensions, and explain your choices.
- Understanding of SCD Types: knowing that Type 2 keeps history via surrogate keys and effective-date columns, while Type 1 overwrites and Type 3 keeps a single prior value in an extra column.
- The ETL-to-ELT shift: modern cloud warehouses (Snowflake, BigQuery, Redshift) push transformation into the warehouse using SQL, so the "T" runs after the load on scalable compute rather than in a separate engine.
- Trade-offs between Kimball and Inmon: Kimball builds dimensional marts bottom-up around business processes; Inmon builds a normalized enterprise data model first, then derives dimensional views.
- Performance reasoning: partitioning, clustering, materialized views, and distribution styles — and when each one helps query speed or load time.
How is a data warehouse different from a data lake?
A data warehouse stores structured, schema-on-write data that has been cleaned and conformed for analytical queries. A data lake holds raw data in its native format — structured, semi-structured, or unstructured — with schema applied on read. A lakehouse layers warehouse-style ACID transactions and SQL query performance on top of lake storage, blurring the boundary. Interviewers want to hear you describe when each pattern fits: warehouses for governed BI and reporting, lakes for exploratory and ML workloads, and lakehouses when you want both from one platform.
Key facts
- Tarmac has 15 Data Engineering interview questions on this topic, 10 of them on this page, at difficulty 1–5 of 5.
- Tarmac tracked 1,538 job postings asking for Data Engineering in September 2026.
- Roles asking for Data Engineering advertise a median base salary of £75,000, across 448 job postings as of September 2026.
- Tarmac last reviewed these Data Engineering interview questions on 19 October 2026.
At a glance
| Questions | 10 shown · 15 in the bank |
|---|---|
| Difficulty | 1–5 of 5 |
| Formats | Multiple choice, Ordering, Multiple answer, Code output, True / false, Find the bug, Short answer, Fill in the blank, Flashcard, Coding exercise |
| Interactive | 1 run your code against tests, in the app |
What you'll review
- warehouse architecture patterns
- oltp vs olap
Practice questions
Try one before you open the answer. Pick an option and press Check; it's marked on the spot.
Which data warehouse architecture pattern builds a normalized, enterprise-wide warehouse first (top-down) and then feeds department-level data marts from it?#
Options
Show answer
Inmon's top-down approach builds a normalized, enterprise-wide data warehouse first, then derives department-level data marts from it. The central store integrates data from all sources once, so each mart draws from consistent, governed data. Kimball's bus architecture, by contrast, starts from dimensional marts that share conformed dimensions.
Inmon's approach treats the enterprise data warehouse as the central, normalized (typically third normal form) store of integrated data, and department data marts are derived from it as dependent marts. Kimball's bus architecture works bottom-up, building dimensional marts that share conformed dimensions. A single wide table and schema-on-read raw storage are not the top-down, normalized-core pattern described.
Put these steps of a classic layered data warehouse pipeline in order, from first to last.#
Put these in order
Show answer
In a classic layered data warehouse pipeline, data is extracted from source systems, landed in a staging area, transformed and loaded into the warehouse core, published to data marts, and finally queried by dashboards and reports. Each layer isolates the next from raw source changes and shapes data for consumers.
Data must first be extracted from operational sources before anything can be stored. The raw extracts are landed in a staging area so they are preserved as received. Only then can they be transformed, conformed across sources, and loaded into the central warehouse core. Data marts are built from that core for specific subject areas, and BI dashboards and reports read from the marts last. Each step depends on the output of the one before it, so this sequence is the only valid order.
Which of the following are typical characteristics of OLAP (analytical) workloads? Select all that apply.#
Options
Pick every one that applies.
Show answer
Typical OLAP workloads involve large scans and aggregations over many rows, and they are commonly served by column-oriented storage that reads only the columns a query needs. Frequent single-row writes and primary-key point lookups are hallmarks of OLTP systems instead.
OLAP workloads are read-heavy and analytical: they scan large volumes of data and compute aggregations such as sums and counts across many rows. Columnar storage suits this pattern because a query touching a few columns reads only those columns from disk. The other two options describe OLTP traits: high-frequency small writes from transactions, and fast single-row lookups by key for operational use cases like checkout.
A star schema has a product dimension (dim_product, keyed by product_id) and a sales fact table (facts). The script below rolls up fact amounts by product category. What exact line does it print?#
dim_product = {1: "Electronics", 2: "Grocery"}
facts = [
{"product_id": 1, "amount": 120},
{"product_id": 2, "amount": 30},
{"product_id": 1, "amount": 80},
{"product_id": 3, "amount": 50},
]
totals = {}
for f in facts:
cat = dim_product.get(f["product_id"], "Unknown")
totals[cat] = totals.get(cat, 0) + f["amount"]
print(sorted(totals.items()))Show answer
[('Electronics', 200), ('Grocery', 30), ('Unknown', 50)]
The fact rows for product 1 (120 and 80) map to Electronics, giving 200. The single row for product 2 maps to Grocery, giving 30. Product 3 has no matching dimension row, so dict.get falls back to Unknown and that row contributes 50. Sorting the (category, total) pairs alphabetically gives Electronics, Grocery, Unknown, and printing the list of tuples yields the stated output. This illustrates how a fact row with an orphan foreign key is kept in the rollup under an Unknown member rather than silently dropped.
True or false: In Kimball's dimensional methodology, the enterprise data warehouse is built first as a normalized (3NF) model, and star-schema data marts are then derived from it.#
Options
Show answer
Kimball's dimensional methodology is bottom-up: it builds conformed star-schema data marts first, linked by shared dimensions. Building a normalized 3NF enterprise warehouse first and deriving marts from it is Inmon's top-down approach, so attributing that sequence to Kimball is false.
This describes Inmon's top-down approach, not Kimball's. Kimball's bottom-up methodology builds dimensional data marts (star schemas) first, using conformed dimensions shared across marts to integrate them into an enterprise view. In Inmon's approach, a normalized 3NF enterprise data warehouse is built first and dependent data marts are derived from it. Because the statement attributes Inmon's sequencing to Kimball, it is false.
A warehouse has fact_orders (one row per order, primary key order_id, columns customer_id, order_date, amount) and dim_customer, a Type 2 slowly changing dimension with one row per customer version (columns customer_id, customer_name, valid_from, valid_to). The query below should report each order once with the customer name that was in effect on the order date, and the order's amount. Some order totals are inflated. Identify the line-level bug.#
SELECT
f.order_id,
d.customer_name,
SUM(f.amount) AS total_amount
FROM fact_orders f
JOIN dim_customer d
ON d.customer_id = f.customer_id
GROUP BY f.order_id, d.customer_name;Show answer
The bug is on line 7.
The join on line 7 matches each order to every historical version of its customer, because it only compares customer_id and never restricts the dimension row to the version valid on order_date. A customer with several SCD Type 2 versions therefore produces several joined rows per order, and SUM(f.amount) counts the same amount once per version. The fix is to add a validity-range predicate such as f.order_date >= d.valid_from AND f.order_date < COALESCE(d.valid_to, '9999-12-31') to the join condition, so each order matches exactly one dimension row.
Compare how the Kimball bus architecture and the Inmon corporate information factory achieve integration across subject areas. In your answer, name the mechanism Kimball uses to keep separately built data marts consistent with each other, and state what Inmon's central layer is modeled as and where dependent data marts get their data from.#
Show answer
Kimball's bus architecture integrates separately built star-schema data marts through conformed dimensions: dimensions such as Customer or Date are defined once, with identical keys, attributes, and grain, and are reused across fact tables, which the bus matrix documents. Inmon's corporate information factory instead builds a central enterprise data warehouse modeled in normalized third normal form (3NF) that integrates all subject areas, and the dependent data marts are derived downstream from that normalized store rather than being integrated with each other directly.
Kimball integrates by conforming dimensions across marts so that drill-across queries line up, coordinated through the bus matrix. Inmon integrates by funneling all source data into a single normalized enterprise warehouse first, and marts are dependent views or extracts of that store. An answer is correct when it names conformed dimensions for Kimball and a normalized (3NF) central warehouse feeding dependent marts for Inmon; the two differ in whether integration happens across marts (bus) or in one central model before marts (Inmon).
In a Data Vault 2.0 model, unique business keys are stored in _____ tables, associations between those business keys (such as a customer placing an order with a product) are stored in _____ tables, and descriptive attributes tracked over time are stored in _____ tables.#
Show answer
In a Data Vault 2.0 model, unique business keys are stored in hub tables, associations between those business keys (such as a customer placing an order with a product) are stored in link tables, and descriptive attributes tracked over time are stored in satellite tables.
Data Vault separates the three concerns into distinct table types. Hubs hold the unique business keys of an entity and little else. Links record relationships or transactions between hubs, so they capture many-to-many associations without embedding descriptive data. Satellites hang off hubs or links and store descriptive attributes along with load-date history, which lets the model absorb source changes without restructuring the core keys and relationships.
In Data Vault 2.0, hubs, links, and satellites are keyed by a hash of the business key (for example, an MD5 or SHA-1 digest of the normalized business key string) instead of a database-generated sequence surrogate. Explain the concrete loading and architectural benefits of this choice over sequence keys, and name one real cost or risk it introduces.#
Show answer
Benefits: each loader can compute the parent key deterministically from the business key alone, so there is no lookup against the hub to fetch a sequence value. That removes a load-order dependency and lets hubs, links, and satellites load in parallel, in separate batches, streams, or on different platforms. The same business key yields the same key in every environment, so dev, test, and prod, or two warehouses, stay joinable without a key-mapping table, and satellites can be loaded without waiting on hub inserts. Cost or risk: hash collisions (theoretically possible, usually mitigated by a wide digest and collision monitoring), plus storage and join cost from wide char keys, and the need to normalize business keys (trimming, casing, delimiters, null handling) consistently, since any inconsistency produces different hashes for the same entity.
The key idea is that a deterministic key removes the sequence-generation lookup, which is what forces Kimball-style loads to run dimension-before-fact and makes parallel loading and cross-environment consistency hard. The trade-off is that correctness now depends on consistent normalization and on the hash function's collision resistance and key width, which a sequence never required. A strong answer names both the decoupling benefit and a concrete risk such as collisions, key width/storage, or normalization drift.
In a warehouse with a Type 2 slowly changing dimension, each dimension row is a version of an entity with a validity interval. Implement point_in_time_join(dim_rows, facts) in Python.#
Starter code
def point_in_time_join(dim_rows, facts):
# TODO: attribute each fact to the customer's tier valid at event_ts
return [[cid, ts, amt, None] for cid, ts, amt in facts]
Your solution must pass
- visible: mixed customers, gaps, unknown id
- visible: no facts
This one is written and run, not read. Solve it in the app and your code is executed against these tests and the hidden ones.
Related interview questions
Job market
See data-engineering salaries and hiring demand from live job postings.
The other 5 questions
This page shows 10 and marks what you pick. That's as far as a page can go. A free account opens the other 5 and keeps every answer. What you miss comes back until it's right: after a day, then at longer gaps.
Free · the whole bank · 100 marked answers per 30 days · written feedback on the paid plan