Back to Blog

Data Warehouse Engineer Interview Questions 2026

Big DataHiringIT Hiring

Last updated: November 16, 2026

By Devin Hornick, Co-Founder, KORE1

The best data warehouse engineer interview questions in 2026 hand the candidate a printed query, dimension table, or query profile and ask what is wrong with it, because this seat owns the model, the load, and the bill. Platform trivia and a SQL puzzle still earn a slot in the loop. They can’t carry it alone.

Last spring a medical-supplies distributor outside Columbus, Ohio, about 600 people, found its Snowflake revenue running $1.1 million above the ledger on roughly $18 million of shipped sales. (A composite, details changed. The pattern is familiar.)

The warehouse engineer they had hired in April came out of a spotless loop. Five hours of it. Clustering keys, virtual warehouse sizing, a window function puzzle on a whiteboard, and a certification on the resume, the whole package a hiring manager reads as proof of a senior engineer who knows the platform. Three weeks into the job he added a join to the shipments table so finance could see ship dates next to revenue. An order that went out in two boxes now counted twice. Eleven days. That is how long it took anyone to trace it, and two board slides went out with the wrong number in the meantime. Nobody in that loop had ever put a query in front of him and asked what one row of the result stood for. Not once.

That question is the subject of this page. After thirty years of placing technology people, the loop I trust least is the one that quizzes the platform and never touches the data. Most published questions for this seat ask what a micro-partition is or how auto-suspend works, and a prepared candidate has every one of those memorized, which is fine, since a memorized answer proves memory. Nothing more. The seat needs somebody who can look at a query, a dimension table, or a profile that a colleague wrote and see what is off in about two minutes. That is what we test.

Here is where I stand. KORE1 earns a fee when a warehouse engineer we introduced accepts an offer, and a loop that tests the wrong things costs us as well, since a placement that leaves in six months is a search we run twice. Our data warehouse engineer staffing desk screens candidates with printed versions of the exercises below before a client panel ever meets them. Run them yourself and hire somebody we never met. I mean that.

Hiring manager and a data warehouse engineer candidate talking across a walnut table in a bright meeting room during an interview

Where This Loop Stops and the Neighboring Ones Start

A data warehouse engineer owns the analytical store, which in practice means the dimensional model, the load logic, the query layer, and the bill. Our guide to hiring a data warehouse engineer covers the profiles, the Snowflake-or-Databricks decision, and a four-round loop. This page fills in the second and third rounds of that loop, the SQL-and-modeling hour and the platform-and-cost hour, with exercises that test judgment instead of recall. If the posting is not written yet, start from our posting template for a data warehouse engineer so the loop tests what the ad promised.

Four neighboring loops already cover ground this page skips. Pipelines, Python, and system design live in our data engineer interview questions. Sizing a virtual warehouse on one vendor’s platform is in the Snowflake engineer set, and Spark internals are in the big data engineer questions. Modeling judgment at the architect level sits in the data architect questions, and dbt craft in the analytics engineer set. Those rounds exist somewhere. Assume them.

Not every seat needs every exercise. This table says where to spend the hour, using the seat names from our hub page. Choose before you schedule.

Seat you are fillingSpend most of the hour onKeep short
Dimensional modeling engineerGrain, then historyThe profile
Platform and cost engineerThe profile, then the loadHistory
Migration leadThe refactor check, then grainThe profile
ELT and integration engineerThe load, then the refactor checkHistory
BI and semantic layer engineerGrain, then historyThe load

Questions About Grain

Grain is what one row of a table stands for. The Kimball Group calls declaring the grain the pivotal step in dimensional design, a binding contract on everything that follows, and says different grains must not be mixed in one fact table. Everyone can recite that. Fewer can see it break in a query somebody else wrote on a Thursday afternoon.

Finance says shipped revenue rose after this join went live. Read the query and tell me why.

Print both. Keep them off a screen. Say nothing else.

SELECT SUM(l.line_amount) AS shipped_revenue
FROM fact_order_line l
JOIN shipment s ON s.order_id = l.order_id
WHERE s.ship_date >= '2026-10-01';
OrderLine amountsShipmentsTrue revenueWhat the join returns
1001$200 + $180 + $1002$480$960
1002$3501$350$350
1003$90 + $601$150$150
Total$980$1,460

The join fans out. Order 1001 has three lines and went out in two boxes, so each line appears twice and the order is worth $960 instead of $480. On this sample the result is $1,460 against a true $980, which is 49 percent too high. Real tables split far fewer orders than this one does, and that is how a 6 percent error survives a glance. A strong candidate spots it inside two minutes and says the word grain without being prompted. Lines on one side, boxes on the other, two different things a row can mean.

The fix separates them. The weak fix is DISTINCT, which hides the duplicates and sometimes deletes real ones, since an order can legally carry two identical lines. A better answer summarizes shipments to the order grain before the join, or keeps ship date in its own shipment-grain table and joins at the reporting layer. The best answer adds what stops it from happening again, a uniqueness test on the declared grain and a row count compared before and after every new join. Ask for that last piece. A candidate who stops at the fix has patched one query. One who adds the test has patched the next ten.

You inherit a fact table with 400 million rows and no documentation. How do you find out what one row means?

By testing it. They pick the columns that ought to be unique, count rows against distinct combinations, and see what breaks. They ask the source team which event creates a row, and they read the oldest and newest rows side by side for a change in meaning, because grain drifts when a source system gets replaced. A strong candidate expects the answer to be “it depends on the year.” A weak one reads the table name and trusts it. Trust the table name last.

Orange cord threaded through a brass ring on an oak table, representing a join that can multiply rows in a data warehouse fact table

Questions About History

Customers move, products get renamed, a rep changes territories. The standard answer is a type 2 slowly changing dimension, which the Kimball Group describes as adding a new row with a new surrogate key, plus at least three extra columns for the effective date, the expiration date, and a current-row indicator. dbt’s snapshots implement the same idea over mutable source tables and write dbt_valid_from and dbt_valid_to. Building one is easy. Joining to one correctly is where candidates get caught.

A customer moved from West to Central on March 1. Read the join and tell me what the West region report says.

Print the dimension, the query, and the orders. The move took effect March 1, so an order dated March 1 belongs to Central.

dim_customer
sk    customer_id  region   valid_from   valid_to
9001  4410         West     2025-01-01   2026-03-01
9002  4410         Central  2026-03-01   9999-12-31

SELECT d.region, SUM(f.order_total) AS revenue
FROM fact_order f
JOIN dim_customer d
  ON d.customer_id = f.customer_id
 AND f.order_date BETWEEN d.valid_from AND d.valid_to
GROUP BY d.region;
Order dateAmountArrived in the warehouseCorrect region
2026-02-20$2502026-03-05West
2026-02-27$4002026-02-27West
2026-03-01$9002026-03-01Central
2026-03-04$7002026-03-04Central

March 1 matches both rows. BETWEEN includes both ends, and the old row ends on the day the new one begins. Touching boundaries. West reports $1,550 where the right answer is $650, and the total comes out at $3,150 against a true $2,250, which is 40 percent too high for a table that every sales director reads on Monday morning. Whoever set the current row’s end date to 9999-12-31 did the right thing, since dbt’s documentation suggests exactly that for easier date-range queries. The BETWEEN stayed.

Listen for the convention before the query. A strong candidate says start inclusive, end exclusive, and then writes the join so the end date is a strict less-than. Better still, they ask which convention this table uses before touching anything. Candidates who have never built a type 2 dimension find the problem the slow way, by running it and staring at a total that is too big.

The February 20 order arrives on March 5. Which region does it belong to, and what does your load have to do to get it right?

West. It happened before the move. The load has to look up the dimension row that was valid on the order date, not the one that is current on the day the row shows up, and that mistake is the one most first-time builders make. Then comes the follow-up I score highest. February’s regional report went out a week ago. Who needs to hear that West moved by $250, and how does the warehouse keep both versions so nobody wonders which deck is stale?

Two oak planks meeting at a seam with a single brass bead resting on the boundary, representing a type 2 dimension date range that touches at its end points

Questions About Loads You Can Run Twice

A load that can’t be re-run safely sits one failed night away from an incident. Ask about idempotency in the abstract and every candidate says the word. Put a MERGE in front of them instead. Watch what happens.

MERGE INTO dim_product t
USING stg_product s ON t.product_id = s.product_id
WHEN MATCHED THEN UPDATE
  SET t.list_price = s.list_price, t.updated_at = s.updated_at
WHEN NOT MATCHED THEN INSERT (product_id, list_price, updated_at)
  VALUES (s.product_id, s.list_price, s.updated_at);

Two rows for product 5512 arrive in one file, the original price and a correction. The product is already in the table. What happens?

It depends on the platform. That is the point. On Snowflake, matching one target row against two source rows with different values is nondeterministic, and by default the merge returns an error, because the ERROR_ON_NONDETERMINISTIC_MERGE parameter is TRUE. A product that is new to the table takes the other branch, and per Snowflake’s MERGE documentation the target gets one copy for every source copy. Two rows for one product. Candidates who work in BigQuery, Databricks, or Redshift should say what the same file does there, and if they aren’t sure, the right move is to say they would test it. Unsure is fine. Confident and wrong is not.

The follow-up is the useful part. Picture a team that set that parameter to FALSE a year ago because a nightly job kept going red, and the job turned green. What did that buy, and what did it cost? A strong candidate says the failure didn’t go away, it changed shape. Per the same documentation, when the parameter is FALSE one of the duplicate rows is chosen and which one is not defined, so the table now holds an arbitrary price for product 5512, and the first anyone hears of it is a customer quoting last week’s number. The real fix sits upstream. Dedupe on the key with a stated tiebreaker, latest updated_at first and file sequence second, and add a uniqueness test on the target so a bad file stops the line.

Questions About Reading the Profile

Snowflake’s documentation describes pruning in plain terms. A query that filters on a range covering 10 percent of the values should ideally scan about 10 percent of the micro-partitions. The query profile reports it as Partitions scanned against Partitions total. Print the profile below. It is constructed for this page and not taken from a client system.

TableScan   EVENTS_FACT          Filter: customer_id = 88213
Partitions scanned                4,812
Partitions total                  4,816
Bytes scanned                     61.3 GB
Bytes spilled to remote storage   0
Rows returned                     1,940

Load pattern: appended hourly, in event-time order. No clustering key.

One customer’s 1,940 rows, and the query reads nearly the whole table. Why, and what would you do?

4,812 of 4,816. That is 99.9 percent. Snowflake’s documentation says tables are partitioned using the order in which data is inserted or loaded, so a table appended by event time has each customer’s rows spread across every hour’s partitions, and a filter on customer can’t skip any of them. The data is perfectly healthy. It is just ordered for a question nobody is asking.

The options are a clustering key on customer, a second table ordered for that access path, or doing nothing. One has a price tag. Per Snowflake’s Automatic Clustering documentation, the service consumes credits, and changing a clustering key triggers a one-time cost on top of ongoing maintenance. So the sharpest answer arrives as a question. How often does this query run, and what does it cost today? A candidate who reaches for the clustering key in the first ten seconds owns a hammer. One who asks about frequency has been handed a bill before.

The Question That Catches a Refactor

Last one, and the favorite of every migration lead I know. Rebuild a model, rewrite a legacy report in a new platform, move a table across schemas, and the same trap waits at the end. Hand over this comparison.

CheckOld modelRefactored model
Row count1,204,1181,204,118
Total revenue$48,210,447.12$48,210,447.12
Northeast revenue$14,602,118$14,643,236
Southeast revenue$9,885,412$9,844,294

The new model matches the old one on rows and on total revenue, to the cent. Do you sign off?

No. Northeast gained $41,118 and Southeast lost the same amount, so something is assigning rows to the wrong region. Two errors canceled. Every total looks perfect. A strong candidate says that within a minute and then says how to find it. Compare the two models at the finest grain, with a hash per row built from the key and the measures, anti-join in both directions, then diff by each attribute until the region column lights up. They also ask what changed in the joins and in how nulls are handled, since a lookup table with a missing key quietly sends rows somewhere else.

Weak answer. Rerun the counts and ship. If the search is for a migration lead, our write-up on staffing a data warehouse migration phase by phase shows where this check sits in the parallel run.

What a Strong Answer Names, and What a Rehearsed One Reaches For

Not everyone on the panel has declared a grain or rebuilt a dimension. Hand them this table. It tells them what to listen for.

QuestionA strong answer namesA rehearsed answer reaches for
Revenue up after a new joinFan-out, two grains, summarize first, a uniqueness testDISTINCT
The 400-million-row table with no docsTesting uniqueness, the source event, drift across yearsReading the table name
The customer who moved regionsStart inclusive, end exclusive, an interval that never touchesBETWEEN, and the word Kimball
The order that arrives lateKey lookup as of the order date, restating a published reportJoining to the current row
The MERGE with two source rowsWhat the platform does, a dedupe tiebreaker, a target testSaying the load is idempotent
The profile that scans everythingLoad order, how often it runs, what clustering costsAdd a clustering key
Totals tie, regions don’tOffsetting errors, a row hash, an anti-join both waysRerunning the count

Two Sections, Printed, and Nothing on a Screen

Take two sections for the seat from the first table, one or two questions from each, and give the printed pages whatever time remains. Don’t cover all five. An hour that reaches the refactor check has skipped something that mattered more.

Put somebody in the room who owns an answer. The analyst who closes the books each month, or the BI lead whose dashboard breaks first, will recognize a good response from the first sentence and ask the follow-up you wouldn’t think of. Count the questions the candidate asks before answering. A candidate who asks nothing has just told you how they will read the next ticket.

Every candidate now has an AI assistant a keystroke away, and a take-home is the one format where it helps most. A printed page read aloud in a room gives it nothing to paste. Fifteen minutes beats five hours. The strong ones notice.

What the VP of Data Wanted Settled First

Do we make them write SQL live, or is a printed query enough?

A printed query is enough for most of the hour, because reading someone else’s SQL is most of the job and typing under observation mostly sorts candidates by nerves. Keep one short live problem if the panel wants it. The rest is reading. Mark them on what they notice.

Does the platform matter, Snowflake or BigQuery or Databricks?

Less than the posting suggests. Grain, history, and safe reloads transfer across every cloud warehouse, so the first three sections work for any stack. Platform-specific behavior, like how MERGE treats duplicate source rows, is worth one question, and “I would test it” is a respectable answer.

Could a strong analytics engineer pass this?

Often, yes, on grain and history, where dbt work builds exactly these instincts. The thinner spots tend to be load safety and the bill, since analytics engineers rarely own either. A coaching gap. Not a disqualifier. If you are weighing someone for the move, our analytics engineer interview questions cover the side they are leaving behind.

How does this fit into the four-round loop?

It replaces the SQL-and-modeling round and the platform-and-cost round, and each runs about an hour. Keep the screen and the team conversation as they are. Two weeks from first call to offer is a good target, since strong warehouse candidates usually have a second process running and a slow loop is how finalists stop answering email. Speed matters.

What does the offer need to look like?

Base pay for a mid-level data warehouse engineer runs $130,000 to $160,000 in 2026, and senior seats run $160,000 to $200,000. Lead and staff levels reach $200,000 to $260,000. The sources behind those bands are in our data warehouse engineer salary guide, and the salary benchmark assistant prices a specific metro and stack.

Should we bring in a contractor while the direct search runs?

Contract fits a defined build, such as a migration or a six-month modeling cleanup, and direct hire fits a seat you expect to keep for years. Through contract staffing, data warehouse engineers run roughly $110 to $175 an hour depending on stack and seniority, and a short paid exercise on your own tables lets you watch them start the job. Plenty run both.

Take One Query From Your Own Warehouse and Print It

If one idea from this page makes it into your next loop, make it that. Pull the longest join feeding your revenue dashboard. Print it. Ask someone who did not write it what one row of the result stands for. Whatever takes them more than ten minutes to answer is your interview.

If you want help building the exercise, bring the query and the org chart to our data warehouse recruiters and we will build the exercise and the shortlist from them. Of the people we place, 92 percent are still with the client when the year is up, and our IT searches average 17 days from first call to accepted offer. For the roles that sit beside this one, we also recruit data scientists and data engineers.