Interview preparation

Microsoft Fabric Interview Questions and Answers for Data Engineers

Practical questions and answers for data engineers, from fundamentals to production architecture.

  • 20 questions
  • Beginner → Senior
  • Production-focused

Fabric interviews increasingly test judgment, not definitions. Each answer here is written to be spoken in your own words: a short answer, why it matters in production, what a strong answer usually demonstrates, the traps to avoid, and where to go deeper.

Microsoft Fabric interview preparation covering Lakehouse, Delta, pipelines, notebooks, Warehouse, capacity and architecture from beginner to senior level.

At a glance

How the levels work

Q01BeginnerFabric Fundamentals

What is Microsoft Fabric?

Short answer

Microsoft Fabric is a software-as-a-service analytics platform that brings data integration, data engineering, data warehousing, real-time analytics, data science and Power BI into one product. All of these workloads share one data lake, OneLake, one capacity-based compute and billing model, and one security and governance layer. A table written by a Spark notebook can be queried with T-SQL and reported on in Power BI without copying it to another service.

Why it matters in production

Fewer moving parts means fewer integrations to secure, deploy and monitor. But the shared foundation also creates shared risks: every workload on a capacity competes for the same compute, and workspace and capacity design decide who can see what and who slows down whom.

What the interviewer is looking for

A strong answer usually demonstrates that you see Fabric as a set of workloads on shared storage and shared compute, not as one big tool. Naming OneLake and capacity in the first minute shows you understand what actually ties it together.

Watch out

“All-in-one” is a useful summary but an oversimplification. You still choose between a Lakehouse and a Warehouse, between pipelines, notebooks and dataflows, and you still design workspaces, environments and capacity. Fabric also does not replace every Azure service: operational databases, specialized ML platforms or a mature Databricks estate often stay where they are and connect to Fabric through shortcuts or mirroring.

Back to all questions ↑

Q02BeginnerOneLake & Lakehouse

What is OneLake, and why does it matter?

Short answer

OneLake is the single, organization-wide data lake that comes with every Fabric tenant. There is exactly one per tenant, it is built on Azure Data Lake Storage, and it is organized by workspaces and items: each workspace appears as a container and each Lakehouse or Warehouse as a folder inside it. Tables are stored in open formats, Delta Parquet and, more recently, Apache Iceberg, so the Fabric engines can work on the same copy of the data. Shortcuts let you reference data in other workspaces or in external storage such as ADLS or Amazon S3 without copying it.

Why it matters in production

Most of the cost and risk in a data platform comes from copies: every copy has to be refreshed, secured and reconciled. OneLake lets Spark, T-SQL and Power BI Direct Lake read one physical copy, and shortcuts let teams share data across workspaces without building another pipeline.

What the interviewer is looking for

A strong answer usually demonstrates that you understand OneLake as the storage foundation under all items, with open formats as the reason different engines can share data, and shortcuts as the tool for avoiding duplication.

Watch out

Do not say that OneLake makes every workload physically identical. Engines still own their write paths: Spark writes Lakehouse tables, the Warehouse engine writes Warehouse tables, and some workloads keep their own optimized storage and expose data to OneLake as an option. A Power BI import model is still a copy. And a shortcut is a reference, so the source’s availability, permissions and performance still apply.

Back to all questions ↑

Q03BeginnerOneLake & Lakehouse

What is the difference between a Fabric Lakehouse and a Fabric Warehouse?

Short answer

Both store their tables as Delta in OneLake, but they are built for different ways of working. A Lakehouse holds Delta tables and raw files, and you write to it mainly with Spark: notebooks, Spark job definitions, pipelines or dataflows. It gets an automatic, read-only SQL analytics endpoint for T-SQL queries. A Warehouse is a SQL-first item: you create tables, load and transform data with T-SQL, including INSERT, UPDATE, DELETE and multi-table transactions, and manage it the way a SQL team expects.

The choice usually follows the write path and the team: Python and Spark engineers handling files and semi-structured data lean towards a Lakehouse; SQL engineers building dimensional models and stored-procedure ETL lean towards a Warehouse. Many platforms use both.

Why it matters in production

The write path decides your tooling, skills, deployment and testing. Picking the item that fights your team’s skills creates friction for years.

What the interviewer is looking for

A strong answer usually demonstrates that you choose by workload, write pattern and team, and that you know the two can be combined, for example a Lakehouse for Bronze and Silver and a Warehouse or Lakehouse for Gold.

Watch out

“Lakehouse is Spark, Warehouse is SQL” is the most common incomplete answer: a Lakehouse is queryable with SQL through its endpoint, and Spark can read Warehouse tables. Also, the SQL analytics endpoint is not a Warehouse: it does not support writes to the Lakehouse’s Delta tables.

Back to all questions ↑

Q04BeginnerDelta & Data Engineering

What is a Delta table?

Short answer

A Delta table is a set of Parquet data files plus a transaction log, the _delta_log folder, that records every change to the table as an ordered commit. The log is what turns a folder of files into a table: it gives ACID transactions, so readers never see half-written data; schema enforcement, so a write with the wrong columns is rejected unless you explicitly allow schema evolution; and history, so you can inspect past versions and query them with time travel. In Fabric, Delta is the default table format: Lakehouse tables are Delta, and Warehouse tables are stored as Delta in OneLake too.

Why it matters in production

Delta is what makes reruns, MERGE, concurrent readers and rollback investigation possible on a data lake. It also explains Fabric performance behaviour: updates and deletes write new files, so tables need maintenance.

What the interviewer is looking for

A strong answer usually demonstrates that you know the transaction log is the key idea, and you can connect it to practical consequences: atomic writes, schema control, history and file maintenance.

Watch out

Parquet alone is not Delta. A Delta table has no SQL Server-style indexes or enforced primary keys, so uniqueness is your pipeline’s job. And time travel only reaches as far back as the retained files: VACUUM removes old versions’ data files.

Example

-- Spark SQL in a Fabric notebook
DESCRIBE HISTORY sales_orders;
SELECT COUNT(*) FROM sales_orders VERSION AS OF 12;

Back to all questions ↑

Q05WorkingWarehouse & SQL

What is the SQL analytics endpoint in Microsoft Fabric?

Short answer

Every Lakehouse automatically gets a SQL analytics endpoint: a T-SQL surface over the Delta tables in its Tables area, running on the same engine as the Fabric Warehouse. You can query and join those tables, create views, functions and stored procedures, and apply SQL permissions, including row- and column-level security. But it’s read-only for the Lakehouse’s tables: data changes go through Spark or other Delta writers. It picks up table changes through a background metadata sync, so there can be a short lag.

Why it matters in production

It is how SQL users, reports and many tools read Lakehouse data. Pipelines that write with Spark and immediately read through the endpoint must account for sync lag, or they validate stale data. Microsoft documents the lag as usually under a minute, longer with many lakehouses per workspace, very large change volumes or poorly maintained tables, and you can trigger a sync manually in the portal or through the REST API (Microsoft Learn, August 2026).

What the interviewer is looking for

A strong answer usually demonstrates that you know the endpoint is read-only over Delta tables, how it differs from a Warehouse, and that metadata sync is a real operational detail rather than an implementation footnote. Views, functions and stored procedures persist in the endpoint, and object-level security is available too.

Watch out

Treating the endpoint as a Warehouse, expecting to add indexes, or assuming every Spark data type and Delta feature is visible. Tables outside Tables, for example Delta files under Files, are not exposed. SQL permissions set on the endpoint protect SQL access only, not Spark or OneLake access to the same files.

Back to all questions ↑

Q06BeginnerPySpark & Notebooks

When would you use PySpark instead of Spark SQL in Fabric?

Short answer

PySpark and Spark SQL run on the same Spark engine and the same optimizer, so equivalent logic produces essentially the same plan and the same performance. The choice is about expressing the work clearly. I reach for Spark SQL for set-based transformations, joins and aggregations a SQL team can read and review. I reach for PySpark when the logic needs control flow, parameters, loops over tables or files, reusable functions, configuration-driven transformations, or Python libraries. In a Fabric notebook you can mix both: spark.sql() from Python, or a %%sql cell next to PySpark cells.

Why it matters in production

Readability decides who can maintain a pipeline at 2 a.m. A transformation written in the team’s strongest language, with reusable pieces tested once, fails less often than a clever one.

What the interviewer is looking for

A strong answer usually demonstrates that you know both APIs compile to the same execution engine and that you choose by maintainability, team skill and the shape of the logic.

Watch out

“PySpark is faster than Spark SQL” is a myth for equivalent DataFrame logic. The real performance trap is the opposite: row-by-row Python UDFs and collect() or toPandas() on large data move work out of Spark’s optimized engine or onto the driver, and can make PySpark code much slower.

Back to all questions ↑

Q07WorkingPipelines & Data Factory

Pipeline, notebook, Dataflow Gen2 or Copy job: how do you choose?

Short answer

I separate three jobs: moving data, transforming it and orchestrating the steps. A Copy job handles straightforward movement, including incremental and CDC copies. Notebooks handle code-first transformation in Spark: complex logic, large volumes, MERGE into Delta. Dataflow Gen2 suits low-code shaping when analysts own the logic and volumes are moderate. Pipelines orchestrate: order, dependencies, parameters, retries and schedules. In practice they work together: a pipeline lands data with a copy, calls a notebook to transform it, then validates.

Why it matters in production

Picking by habit produces the classic anti-patterns: business logic duplicated in a dataflow and a notebook, a notebook orchestrating other notebooks with try/except, or a pipeline with forty activities that is really a transformation. Each tool keeps its evidence in a different place, so the choice also decides how you monitor and debug.

What the interviewer is looking for

A strong answer usually demonstrates that you think in responsibilities, ingestion, transformation, orchestration and ownership, and that you combine tools deliberately instead of crowning one:

  • Copy job for data movement without building a pipeline: bulk copy, watermark-based incremental copy, or CDC replication where the source supports it, with append, overwrite or merge into the destination (Microsoft Learn, September 2026).
  • Notebooks for complex logic, large volumes, MERGE into Delta, reusable Python, and anything that benefits from testing.
  • Dataflow Gen2 for Power Query shaping owned by analysts or BI developers.
  • Pipelines for ordering, dependencies, parameters, retries, schedules and triggers, failure handling, plus Copy activities for movement inside a larger workflow.

Watch out

“Always use notebooks” and “always use pipelines” are both weak answers. Also avoid outdated claims: Copy job capabilities, connectors and Dataflow Gen2 features change frequently, so verify current support for a specific source before committing to a design.

Example

Daily files land in a Lakehouse. A pipeline triggers on schedule, a Copy job pulls the SQL Server orders table incrementally, a notebook merges both into Silver, a second notebook rebuilds the affected Gold partitions, and a final step checks row counts before the report refresh.

Back to all questions ↑

Q08BeginnerArchitecture & Medallion

What is Medallion Architecture, and do you always need Bronze, Silver and Gold?

Short answer

Medallion Architecture organizes data into layers with different responsibilities. Bronze keeps what the source sent, close to raw, so you can audit and replay. Silver makes data trustworthy: cleaned, deduplicated, typed and conformed across sources, with business keys established. Gold shapes data for consumers: dimensional models, aggregates or wide tables for reports, semantic models and APIs.

No, you do not always need all three. Medallion is a pattern, not a Fabric rule. A layer earns its place when it solves a real problem: replay, conformance across sources, serving performance or isolation. A small, clean source might go straight from landing to a curated table; a reference dataset may never need Gold.

Why it matters in production

Every layer is another copy to store, refresh, test, secure and monitor. Layers without a clear purpose multiply cost and failure points without making the data better.

What the interviewer is looking for

A strong answer usually demonstrates that you can describe what each layer is responsible for, and that you apply the pattern with judgment rather than by default.

Watch out

Business logic hidden in Bronze, Silver that is only a copy of Bronze, and Gold that exists because “the diagram has three boxes”. Also, layers are logical: they can be separate Lakehouses, schemas or naming conventions, so describe how you would separate them, not just that you would.

Back to all questions ↑

Q09WorkingDelta & Data Engineering

How would you design an incremental load in Fabric?

Short answer

First I pick how changes are detected, based on what the source offers: a reliable high-watermark column, Change Tracking or CDC, file arrival, or Mirroring or a Copy job when replication into OneLake fits better than custom code. Then each run processes a bounded window: capture the upper bound at the start, read changes since the last watermark, and apply them with an idempotent Delta MERGE on the business key. The watermark advances only after the write commits, so a failed run can simply be rerun.

Why it matters in production

Full reloads stop scaling; incremental loads fail in subtle ways: silent gaps, duplicates, missing deletes. Most incidents come from advancing the watermark at the wrong moment.

What the interviewer is looking for

A strong answer usually demonstrates that you know several change-detection options and their limits, and that you treat watermark advancement and reruns as the core correctness problem:

  • a high-watermark column, such as a reliable modified_at timestamp or an increasing ID;
  • Change Tracking, which tells you which rows changed, or CDC, which captures the change rows themselves, including deletes;
  • file arrival, tracking which files have already been processed;
  • Mirroring or a Copy job in incremental or CDC mode.

Deletes, late-arriving data and a periodic reconciliation against the source are part of the design, not afterthoughts.

Watch out

Using now() at the end of the run as the next watermark (rows committed during the run are skipped), timestamps that are not updated on every change, assuming Change Tracking provides history, and appending without deduplication so that a rerun doubles the data.

Example

# Simplified: bounded window, idempotent write, then advance
upper = spark.sql("SELECT max(modified_at) FROM source_orders").first()[0]
changes = spark.table("source_orders").where(f"modified_at > '{last_wm}' AND modified_at <= '{upper}'")
merge_into_silver(changes)            # MERGE on order_id
save_watermark("orders", upper)       # only after the MERGE committed

Back to all questions ↑

Q10WorkingDelta & Data Engineering

How does Delta MERGE work, and what can go wrong?

Short answer

MERGE matches a source dataset against a target Delta table on a condition, usually the business key. Then it updates or deletes matched rows and inserts unmatched ones. Delta never edits files in place: Spark finds the target files that contain matches, rewrites them with the changes, and commits the new files atomically. The usual problems are duplicate source keys, which make the MERGE fail; conditions the engine can’t prune, which force wide scans; and small changes spread across many files, which cause large rewrites.

Why it matters in production

MERGE is the workhorse of incremental Silver and Gold loads, and often their slowest step. Correctness problems such as duplicates and phantom inserts show up much later in reports.

What the interviewer is looking for

A strong answer usually demonstrates that you understand MERGE rewrites files, that you deduplicate and validate the source before merging, and that you design the condition so the engine can narrow the files it touches. What goes wrong in practice:

  • Duplicate source keys. If several source rows match one target row, the MERGE fails, so deduplicate the source first.
  • Wide scans. A match condition the engine cannot prune forces it to read most of the target.
  • Large rewrites. Touching a few rows spread across many files rewrites all those files, which is slow and creates churn.
  • Missing or null keys that silently become inserts.
  • Non-idempotent logic, such as incrementing counters, which breaks reruns.

MERGE can also act on target rows not matched by the source, for example to delete them.

Watch out

Treating MERGE as free, using it where a plain append or a partition overwrite would be simpler, and assuming Delta enforces a primary key for you. It does not.

Example

from delta.tables import DeltaTable
src = changes.dropDuplicates(["order_id"])          # one row per key
(DeltaTable.forName(spark, "silver_orders").alias("t")
   .merge(src.alias("s"), "t.order_id = s.order_id")
   .whenMatchedUpdateAll()
   .whenNotMatchedInsertAll()
   .execute())

Back to all questions ↑

Q11WorkingDelta & Data Engineering

What causes the small-file problem in a Fabric Lakehouse?

Short answer

Small files appear when a table gets many small writes: frequent tiny appends, streaming micro-batches, high write parallelism on modest data, MERGE and UPDATE operations that rewrite files, and over-partitioning. They hurt because every file has a fixed cost to list, open and schedule. Thousands of them slow Spark reads, MERGE pruning and the SQL analytics endpoint’s metadata sync. The fix starts upstream with better write patterns. Then I compact the tables and partitions that actually need it.

Why it matters in production

Small-file degradation is gradual: a table that was fast at launch gets slower every day with no code change. Teams often blame capacity first. The files also grow the transaction log.

What the interviewer is looking for

A strong answer usually demonstrates that you can name the write patterns that cause the problem and that you fix the cause, not only the symptom: batch writes sensibly, avoid partitioning by a column with too many values, and use Fabric’s write-time features such as optimized write and auto compaction where their extra write latency is acceptable. Then compact with OPTIMIZE where it is needed.

Watch out

Scheduling OPTIMIZE on every table every hour. Compaction costs capacity, rewrites data and can conflict with concurrent writers. Measure file counts and sizes first, and target recently written partitions or tables that are actually read.

Back to all questions ↑

Q12WorkingDelta & Data Engineering

What is the difference between OPTIMIZE and VACUUM?

Short answer

They solve different problems. OPTIMIZE improves the active layout of a table: it compacts many small files into fewer, larger ones, and can also apply ordering such as Z-Order or V-Order. It writes new files and commits them; the old small files stay on storage because earlier table versions still reference them.

VACUUM deals with storage: it permanently deletes data files that the current table version no longer references and that are older than the retention period, seven days by default. That reclaims space, but it also limits time travel: once old files are gone, you cannot query or restore versions that needed them.

Why it matters in production

Running only OPTIMIZE leaves storage growing with every rewrite. Running VACUUM with too short a retention can break time travel, auditing and long-running readers that still use older versions.

What the interviewer is looking for

A strong answer usually demonstrates that you separate performance (active layout) from storage and retention, and that you choose a retention window from recovery and audit needs.

Watch out

Saying VACUUM makes queries faster. Readers already use the transaction log to find the current files, so deleting unreferenced files mainly saves storage; Microsoft’s guidance says the same (Microsoft Learn, August 2026). Lowering retention below the default to free space quickly is a dangerous production assumption.

Example

OPTIMIZE silver_orders WHERE order_date >= '2026-10-01';  -- WHERE must use partition columns
VACUUM silver_orders RETAIN 168 HOURS;  -- the 7-day default, stated explicitly

Back to all questions ↑

Q13WorkingCapacity & Performance

What are Capacity Units (CUs) in Microsoft Fabric?

Short answer

A Fabric capacity is a pool of compute that workspaces are assigned to, and Capacity Units measure how much compute that pool provides. The SKU name tells you the size: an F2 provides 2 CUs, an F64 provides 64, and a Fabric trial is equivalent to 64 (Microsoft Learn, June 2026). Every workload in workspaces on that capacity, Spark, pipelines, Warehouse queries, Power BI and others, consumes from the same pool, measured in CU-seconds.

Fabric classifies operations as interactive, such as report queries, or background, such as refreshes, pipeline runs and Spark jobs, and spreads their cost over time: interactive operations over minutes, background operations over 24 hours. Bursting lets a single operation run faster than the SKU size, and smoothing pays for it out of future capacity.

Why it matters in production

Capacity is both the bill and the performance ceiling. Because workloads share it, a heavy backfill in one workspace can slow reports in another, and sizing decisions depend on understanding what consumes CUs.

What the interviewer is looking for

A strong answer usually demonstrates that you see CUs as a shared, smoothed budget across workloads and that you would read the Capacity Metrics app before resizing.

Watch out

Treating a CU as a fixed number of CPU cores, or reading the Power BI v-core comparison table as functional equivalence. Microsoft presents it only as a reference for comparing compute size. Also, utilization above 100% does not automatically mean throttling, which is the next question.

Back to all questions ↑

Q14SeniorCapacity & Performance

What causes throttling in Microsoft Fabric, and how would you investigate it?

Short answer

Throttling happens when a capacity uses more compute than its SKU allows, even after smoothing. Interactive work is smoothed over minutes and background work over a day, so a single spike rarely throttles. Sustained overload does, and then Fabric delays or rejects new requests in progressive stages, while running operations finish. To investigate, I start from when the symptom began. Then I open the Capacity Metrics app for that window, drill into the timepoint to see which items consumed the most, and look for overlapping workloads. Finally I decide whether it’s capacity-wide or one item’s design.

Why it matters in production

Throttling turns one team’s backfill into another team’s outage. Without a disciplined investigation, organizations either overspend on capacity or optimize code that was never the problem.

How it works, as documented in August 2026: Fabric smooths interactive operations over at least five minutes and background operations over 24 hours. When smoothed usage keeps borrowing from future capacity, the stages are delays for new interactive requests, then rejection of new interactive requests, then rejection of all new requests, with thresholds based on how much future capacity is already consumed. Microsoft states the policy can change, so check the current documentation rather than quoting thresholds from memory.

What the interviewer is looking for

A strong answer usually demonstrates that you understand smoothing and progressive throttling conceptually, and that you investigate with evidence from the Capacity Metrics app before changing code or buying capacity:

  1. Note when the symptom started: slow reports, delayed jobs, CapacityLimitExceeded errors, or Spark jobs refused or queued.
  2. Open the Capacity Metrics app for that window: the utilization chart, the throttling charts and the system events that record throttling.
  3. Drill through to the timepoint and identify which operations, workspaces and items consumed the most, interactive and background.
  4. Look for overlap: a backfill, a refresh storm, an ad hoc query or a new workload landing on the same capacity.
  5. Decide whether it is capacity-wide or workload-specific. If everything slowed at once, it is capacity. If one item is slow while the capacity is healthy, it is that item’s design.

The fix then follows the cause: reschedule or spread heavy jobs, optimize the dominant item, isolate critical workloads on a separate capacity, or resize, temporarily or permanently.

Watch out

Assuming every slowdown is throttling (Microsoft itself notes that slow performance is often item design), confusing Spark concurrency limits and job queueing with capacity throttling, and quoting exact thresholds as if they were permanent.

Back to all questions ↑

Q15WorkingMonitoring & Production

How do you monitor Fabric pipelines and notebooks in production?

Short answer

I monitor four separate questions, because each needs different evidence. Did it run? Did it succeed? Did it produce correct data? Did it take acceptable time and capacity? Fabric’s Monitoring hub and run history answer the first two well. For the rest, I add row counts, freshness and quality checks after each run, compare durations with each job’s baseline, and keep a custom execution log. That log lets me answer questions across runs and correlate a parent pipeline with its child notebooks.

Why it matters in production

Most data incidents are found by report users unless monitoring covers correctness and freshness, not just success.

What the interviewer is looking for

A strong answer usually demonstrates that you know what Fabric shows out of the box, where it stops, and that you design alerts on outcomes rather than on noise:

  1. Did it run? Schedules and triggers fired, and nothing is stuck or missing. Missing runs are as important as failed ones.
  2. Did it succeed? Pipeline run history and activity runs in the Monitoring hub, notebook and Spark application details, and alerts on failure.
  3. Did it produce correct data? Row counts, freshness and data-quality checks recorded after each run. A green pipeline can still load zero rows.
  4. Did it take acceptable time and capacity? Duration compared with a baseline for that job, startup versus processing time, and the Capacity Metrics app for the same window.

The execution log holds one row per pipeline and notebook execution with IDs, status, row counts, processing window and errors.

Watch out

Alerting only on failures, alerting on everything (alert fatigue), and judging duration in absolute terms instead of against each job’s own baseline.

Back to all questions ↑

Q16SeniorMonitoring & Production

How would you design an execution log for Fabric pipelines and notebooks?

Short answer

One row per execution, written at start and updated at finish, with identifiers that let me reconstruct any run. Each row has an execution ID, a correlation ID shared by everything in one business run, the parent execution for the call tree, and Fabric’s own run IDs so I can jump to its monitoring. It also records status and timing, specific row counts, the processing window, and errors. Retries and deliberate reruns are tracked separately. I store it in a SQL database or Delta table and write the start row before any work, so a crash leaves a visible abandoned row.

Why it matters in production

Built-in run history answers “what failed”; it rarely answers “which batch, which window, how many rows, and is it safe to rerun”. The execution log is what makes debugging, reruns and freshness monitoring fast.

What the interviewer is looking for

A strong answer usually demonstrates the identifier model, especially correlation across parent and child runs, and the retry-versus-rerun distinction. Senior candidates also discuss failure modes of the log itself. The columns:

  • execution_id: unique for this pipeline or notebook execution.
  • correlation_id: shared by everything that belongs to one business run, so a parent pipeline, its child pipelines, notebooks and validations can be queried together.
  • parent_execution_id: the direct caller, which gives the call tree.
  • Fabric run IDs: the pipeline run ID and notebook or Spark identifiers.
  • Status and timing: status, started_at, finished_at, and duration.
  • Row counts that are specific: rows read, inserted, updated, deleted, rejected.
  • Processing window: watermark from and to, and whether the watermark was advanced.
  • Retries and reruns kept separate: retry_count for automatic retries inside one execution, rerun_of_execution_id for a deliberate rerun of a failed execution.
  • Errors: a classified error type and a truncated message, never secrets or full payloads.

Store it where both engines can write and query it, and make the finish update robust, so an “abandoned” row can be closed by a check.

Watch out

Logging one row per record, logging free text that cannot be queried, letting the log block legitimate reruns, and storing secrets or personal data in error messages.

Example

SELECT execution_id, parent_execution_id, item_name, status,
       rows_inserted, watermark_from, watermark_to, retry_count, rerun_of_execution_id
FROM ops.execution_log
WHERE correlation_id = @correlation_id
ORDER BY started_at;

Back to all questions ↑

Q17SeniorMonitoring & Production

A Fabric pipeline failed. How do you debug it systematically?

Short answer

I follow the same sequence every time, so I don’t rerun or change code before I understand the failure. I identify the run, its correlation ID and processing window, then classify the failure: orchestration, code, data, schema, permissions, connectivity or capacity. I follow the failing activity down to the child pipeline, notebook or cell, and check the parameters and data it actually received, plus the platform for that window. Then I test one hypothesis, fix it, and rerun only when I know the rerun is safe. After that I verify downstream and add something to prevent it happening again.

Why it matters in production

Most extended incidents come from guessing: rerunning a partial load and creating duplicates, or fixing the notebook when the real cause was a parameter or the capacity.

What the interviewer is looking for

A strong answer usually demonstrates a repeatable method, evidence before action, attention to parameters and data, and above all safe reruns and downstream verification:

  1. Identify the run. Find the failed pipeline run, its correlation ID and processing window, and what else ran in the same window.
  2. Classify the failure. Orchestration, notebook code, data, schema, permission or authentication, source connectivity, capacity, or a write that failed to commit. Each class has a different first place to look.
  3. Locate the failing layer. Open the activity that failed, then follow it down: a child pipeline, a notebook, the specific cell or operation. Read the activity’s input and output, not only the error text.
  4. Check the inputs. Parameters as received, not as intended: business date, paths, workspace or environment identifiers. Then the data: row counts, schema compared with what the code expects, sample bad records.
  5. Check the platform. Capacity Metrics for the same window, Spark queueing, recent runtime or environment changes.
  6. Form one hypothesis and test it on the smallest unit of work.
  7. Fix, then rerun safely. Confirm the write path is idempotent and the watermark was not advanced by the failed run. Rerunning one failed child can be wrong if upstream state has changed since.
  8. Verify downstream. Validation passes, Gold and semantic models are fresh, and nothing was half-written.
  9. Prevent recurrence with a validation, an alert or a design change, and write a short root-cause note.

Watch out

Reading the notebook error but not the parent pipeline context, ignoring retry counts (a job that succeeded after four retries is not healthy), changing several things at once, and manually patching target data without recording it.

Back to all questions ↑

Q18SeniorCapacity & Performance

A Fabric notebook is three times slower today, but the code did not change. What would you check?

Short answer

“The code didn’t change” narrows the search to everything else. So I compare today’s run with a comparable baseline and split the time before guessing. Is the delay in session startup or in processing? Startup points at environments, pools or capacity. Processing points at data: has the volume or window grown, or a key become skewed? Then I check capacity and concurrency for that window, and the Spark stages for long shuffles, skewed tasks or spills. I also look at table layout, like small files or a MERGE now touching most of the table, and at runtime or library changes. Then I change one thing and measure again.

Why it matters in production

Performance regressions without code changes are common in shared platforms, and they are where teams waste the most time optimizing the wrong layer.

What the interviewer is looking for

A strong answer usually demonstrates a structured, evidence-led approach that separates startup from processing and code from platform, and resists rewriting the notebook first:

  1. Confirm the baseline. Same job, same window size, same code version. Was yesterday’s run typical, and is today’s slowdown consistent across runs?
  2. Startup or processing? Compare the time from activity start to the first cell with the processing time. Slow startup points at session configuration, environment libraries, pools or capacity, not the code.
  3. Data volume and shape. Did input grow, did a backfill widen the window, did a key become skewed? Execution-log row counts answer this quickly.
  4. Capacity and concurrency. The Capacity Metrics app for the same window: throttling, a heavy job on the same capacity, or Spark jobs queued behind others.
  5. Spark execution. In the Spark application details, look for new long stages, large shuffles, a few tasks running far longer than the rest of their stage (skew), or spills.
  6. Table layout. A growing number of small files, a MERGE now touching most of the table, or a maintenance job that stopped running.
  7. Runtime or environment changes. A Fabric runtime upgrade, a changed library version in the environment, or new Spark settings, all changes that are not code changes.

Then change one thing, rerun under comparable conditions and measure again.

Watch out

Comparing a cold session with a warm one, tuning Spark settings before checking capacity, and ignoring data growth because “the job has not changed”.

Back to all questions ↑

Q19WorkingGit, CI/CD, Security & Governance

How should Git and CI/CD be used with Microsoft Fabric?

Short answer

Git integration connects a workspace to a branch, so supported items like notebooks, pipelines, semantic models and reports are stored as files you can review and revert. But Git stores definitions, not data or runtime state, so each environment still needs its own configuration. CI/CD is the process around it. Developers work in their own workspaces, merge through pull requests into a protected main branch, and changes are promoted to test and production with deployment pipelines, the REST APIs or fabric-cicd, replacing environment-specific values per stage.

Why it matters in production

Without it, production is edited by hand, environments drift and nobody can say what changed before an incident.

What the interviewer is looking for

A strong answer usually demonstrates that you separate source control from deployment, know what Git does and does not capture, and have a plan for environment-specific configuration. Details worth knowing:

  • Git integration supports Azure DevOps, GitHub and GitHub Enterprise (cloud-hosted; Microsoft Learn, September 2026). Supported items include notebooks, pipelines, Lakehouse and Warehouse definitions, semantic models, reports and environments. Item support varies and some items are still in preview, so check the current list.
  • Table data, run history, credentials and most connection details stay in the workspace.
  • Environment-specific values, such as connections, lakehouse IDs and parameters, are replaced per stage through parameter files, deployment rules or variable libraries.

Watch out

“We connected Git, so we have CI/CD.” Git integration alone is versioning, not deployment. Also: connecting production workspaces to editable branches, expecting data to move with the deployment, and hard-coding workspace or item IDs in notebooks.

Back to all questions ↑

Q20SeniorArchitecture & Medallion

Design a production Fabric architecture for daily sales ingestion and reporting.

The scenario

Hundreds of sales files arrive every day, an operational SQL Server holds orders and customers, the business wants years of history in Power BI, every load must be rerunnable, and the platform needs DEV, TEST and PROD, monitoring and sensible capacity use. This is one reasonable design, not the only correct one; a strong answer explains why each choice fits and what would change it.

Short answer

I’d use a Medallion design. Files land in a Bronze lakehouse and are registered so duplicates are caught. SQL Server changes arrive incrementally through Mirroring, a Copy job or a watermark copy. Bronze stays raw and replayable. Notebooks build Silver with validation, quarantine and MERGE on business keys over a bounded window. Gold is a star schema for Power BI, in a Lakehouse with Direct Lake or a Warehouse, depending on the team. A parent pipeline orchestrates it all with an execution log and monitoring, and Git plus deployment pipelines promote it across environments.

Why it matters in production

This question tests whether you can connect individual features into a system that keeps working when files arrive late, a load fails halfway or volumes double.

What the interviewer is looking for

A strong answer usually demonstrates clear layer responsibilities, an explicit incremental and rerun strategy, observability designed in from the start, and trade-offs stated openly, for example Lakehouse versus Warehouse for Gold, or one capacity versus two. The full design:

  • Ingestion. Files land in a Bronze Lakehouse Files area through a shortcut or copy. A pipeline discovers new files and records each one, so duplicates and partial files are detected. SQL Server changes arrive incrementally, through Mirroring, a Copy job in incremental or CDC mode, or a watermark-based copy, depending on what the source supports.
  • Bronze. Raw files plus append-only Delta tables with ingestion metadata: file name, load time, batch ID. Nothing is cleaned here, so any batch can be replayed.
  • Silver. Notebooks validate, type, deduplicate and conform the data, quarantine bad records instead of dropping them, and MERGE changes by business key. Processing uses a bounded window, and the watermark advances only after the commit.
  • Gold. A star schema for sales reporting, rebuilt for the affected dates rather than fully reloaded. A Lakehouse with Power BI Direct Lake works well for a Spark-oriented team; a Warehouse is a strong alternative for a SQL-first team that wants T-SQL transformations and transactions.
  • Orchestration. A parent pipeline calls parameterized child pipelines and notebooks, passes the business date and correlation ID, and runs validation before the semantic model refresh.
  • Reliability. Idempotent writes, an execution log with correlation IDs and row counts, retries only for transient errors, and documented safe reruns.
  • Monitoring. Failures, missing runs, freshness, row-count anomalies and duration against baseline, plus the Capacity Metrics app.
  • Environments. Git-connected development workspaces, promotion to TEST and PROD through deployment pipelines or fabric-cicd, environment-specific parameters, and table maintenance as a scheduled job.
  • Capacity and governance. Heavy loads scheduled away from reporting hours, critical reporting isolated if contention appears, workspace roles by group, a non-personal identity for scheduled work, and sensitivity labels and lineage through Microsoft Purview.

Watch out

Drawing boxes without explaining failure handling, choosing tools without saying why, ignoring deletes and late data, and presenting one architecture as universally correct. Ask clarifying questions about latency, volume, team skills and compliance before committing.

Go further

The Fabric overview frames the workloads, Incremental Loads covers the change and rerun strategy, Monitoring covers what to watch, CI/CD with fabric-cicd covers promotion, and Governance with Purview covers the governance layer.

Back to all questions ↑

Keep preparing

New questions are added as they are written. Interview questions for other topics live on the interview questions hub. The best preparation is still hands-on: follow the Microsoft Fabric learning path, build the End-to-End Sales Analytics lab, and keep the cheat sheets close for quick reference.