Sales Analytics Pipeline in Microsoft Fabric

Build an end-to-end sales pipeline with PySpark, KQL, and Fabric.

Introduction

30 Second Summary

Every business generates sales data. The challenge is turning that raw data into something useful: clean tables you can query, real-time visualizations, and automated flows that keep everything fresh without manual work.

In this project, you will build an end-to-end sales analytics pipeline in Microsoft Fabric. You will ingest raw CSV data, transform it with PySpark, query it with KQL, and orchestrate the entire flow with a data pipeline.

What You'll Build

By the end, you can paste a raw CSV into your pipeline, hit run, and watch your sales data appear as queryable time-series charts in seconds.

By the end of this project, you'll have:

  • A PySpark notebook that transforms raw sales CSV data into optimized Delta Lake tables you can query instantly in a Lakehouse.
  • Live KQL queries in an Eventhouse that aggregate your sales data and render time-series visualizations you can show to anyone.
  • A data pipeline that orchestrates the entire flow from Lakehouse to Eventhouse, monitored through the Fabric Monitoring Hub with duration breakdowns and status tracking.
  • Secret Mission: Enable workspace monitoring and write KQL queries against pipeline execution logs to build a mini monitoring dashboard.

Are there any prerequisites?

You need an active Microsoft Fabric free trial with capacity enabled. The trial is free for 60 days and includes all Fabric workloads.

Familiarity with SQL and basic Fabric navigation (creating workspaces, finding items) is helpful. No prior PySpark or KQL experience is needed. You will learn both in this project.

Before We Start

Before we dive in, let's lock in what you're about to build and why it matters for DP-700 preparation.

Set Up Your Workspace and Lakehouse

Before you can ingest or transform any data, you need a place for it to live. Microsoft Fabric organizes all your items into workspaces, and a Lakehouse is where your raw files and structured tables are stored together.

In this step, you will create a dedicated workspace for this project, build a Lakehouse inside it, and upload a sample sales CSV file so you have real data to work with in the next step.

In this step, get ready to:
  • Create a dedicated workspace for this project.
  • Create a Lakehouse named SalesLakehouse.
  • Upload a sample sales CSV file to the Lakehouse Files section.
Create a new workspace

A workspace keeps all the items for a single project together. Creating one now keeps your Lakehouse, notebooks, and pipelines isolated from anything else on your trial capacity.

  • In the Fabric portal left navigation pane, select Workspaces.
  • At the bottom of the Workspace pane that opens, select + New workspace.
  • In the Name field, enter SalesAnalytics (or add your initials to make it unique).
  • Expand Advanced. Under Workspace type, confirm Fabric Trial capacity is selected.
  • Select Apply.

Fabric creates the workspace and opens it. You should see an empty workspace page with no items listed yet.

Why a dedicated workspace?

Your Fabric trial capacity is shared across everything you do. A dedicated workspace keeps this project's resources isolated so you avoid naming conflicts and capacity contention with other trial workloads.

Don't see + New workspace?

Your tenant admin may have restricted workspace creation. Confirm your Fabric trial is active by checking your account icon in the top-right corner for trial status. If workspace creation is restricted, ask your admin to add you to the allowed security group.

help me troubleshoot why I can't create a new workspace in Microsoft Fabric

Create the SalesLakehouse

The Lakehouse is where both your raw files and structured Delta tables live. It gives you a Files section for unstructured data and a Tables section for queryable Delta tables.

  • In your new workspace, select + New item.
  • In the search box, type Lakehouse and select Lakehouse from the results.
  • In the Name field, enter SalesLakehouse.
  • Leave the Lakehouse schemas checkbox selected (default).
  • Select Create.

The Lakehouse opens in the Explorer pane. You should see two empty sections: Tables and Files. Both are backed by OneLake and ready for content.

What is a Lakehouse?

A Lakehouse combines data lake flexibility with data warehouse structure. The Files section stores raw data in any format. The Tables section stores structured Delta Lake tables that you can query with both Spark and SQL.

When you create a Lakehouse, Fabric automatically provisions a SQL analytics endpoint for T-SQL queries against your Delta tables.

Don't see + New item?

Make sure you are inside the workspace you just created, not in My workspace. Select Workspaces in the left nav, find your SalesAnalytics workspace, and open it.

help me find my workspace and create a Lakehouse in Microsoft Fabric

Create and upload the sample sales data

You need sample data to transform in the next step. You will create a small CSV file on your local machine and upload it to the Lakehouse Files section.

  • Open any text editor on your computer (Notepad on Windows, TextEdit on macOS).
  • Paste the following sales data into a new file:
OrderDate,ProductCategory,ProductName,Quantity,UnitPrice,Revenue
2024-01-15,Electronics,Wireless Headphones,3,79.99,239.97
2024-01-22,Clothing,Winter Jacket,2,129.99,259.98
2024-02-03,Home,Smart Thermostat,1,199.99,199.99
2024-02-14,Electronics,Tablet Stand,5,34.99,174.95
2024-03-01,Clothing,Running Shoes,4,89.99,359.96
2024-03-18,Home,LED Desk Lamp,6,45.99,275.94
2024-04-05,Electronics,USB-C Hub,3,54.99,164.97
2024-04-22,Clothing,Yoga Mat,8,29.99,239.92
2024-05-10,Home,Air Purifier,2,149.99,299.98
2024-05-28,Electronics,Portable Charger,7,39.99,279.93
2024-06-15,Clothing,Hiking Backpack,3,74.99,224.97
2024-06-30,Home,Robot Vacuum,1,349.99,349.99

What is in this data?

This CSV has 12 orders spanning January to June 2024 across three product categories: Electronics, Clothing, and Home. It includes columns for order date, product details, quantity, unit price, and revenue.

In the next step, you will use PySpark to add Year and Month columns, cast data types, and write this as an optimized Delta table.

  • Save the file as sales_data.csv to your Desktop (or any location you can easily find).

Now upload the file to your Lakehouse.

  • Return to the SalesLakehouse Explorer in the Fabric portal.
  • Hover over Files in the Explorer pane.
  • Select the ... (more options) menu that appears.
  • Select Upload, then Upload files.
  • Browse to the sales_data.csv file on your machine and select it.
  • Select Upload to confirm.

Before you check the result, what do you expect to see in the Files section after the upload completes?

Expand the Files folder in the Explorer. You should see sales_data.csv listed there. The Tables section remains empty because a raw CSV is not a Delta table yet.

Don't see the file after uploading?

Click the refresh icon at the top of the Explorer pane. Upload processing may take a few seconds on trial capacity.

If the upload failed, confirm your file is saved with the .csv extension and is not empty. On macOS, TextEdit may save as .txt by default. Use Format > Make Plain Text before saving.

help me upload a CSV file to my Fabric Lakehouse Files section

Your workspace and Lakehouse are ready with raw data waiting to be transformed. Next up, you will open a notebook and use PySpark to turn that CSV into an optimized Delta table with proper data types and partitions.

Transform Data with PySpark in a Notebook

Your raw CSV is sitting in the Lakehouse Files section, but it is not queryable as a table yet. The data types are all strings, and there are no date partitions for efficient filtering.

In this step, you will create a Fabric Notebook and write PySpark code that reads the CSV, casts columns to proper types, adds Year and Month columns, and writes the result as an optimized Delta Lake table.

In this step, get ready to:
  • Create a notebook from the Lakehouse and write PySpark transformation code.
  • Run the notebook and observe the Spark session and DataFrame preview.
  • Verify the fact_sales Delta table appears in the Lakehouse Explorer.
Create a notebook from the Lakehouse

Fabric notebooks connect directly to your Lakehouse, so the files and tables are immediately accessible via relative paths.

  • In the Fabric portal, open SalesLakehouse from your workspace.
  • In the Lakehouse ribbon at the top, select Open notebook, then select New notebook.

A new notebook opens with SalesLakehouse already attached as the default lakehouse in the left explorer panel.

Why does the lakehouse appear automatically?

When you create a notebook from a lakehouse, Fabric pins that lakehouse as the default. This means any relative file path you use in code (like Files/sales_data.csv) resolves against this lakehouse at runtime.

Write the PySpark transformation code

You will write your PySpark code across three notebook cells. Each cell handles one responsibility: configuring Spark, reading and transforming the data, and writing the Delta table.

  • In the first empty code cell of your notebook, paste the following Spark configuration code:
# Enable V-Order optimization for faster reads
spark.conf.set("spark.sql.parquet.vorder.enabled", "true")

# Enable optimizeWrite to reduce small files
spark.conf.set("spark.microsoft.delta.optimizeWrite.enabled", "true")

What does this code do?

V-Order rearranges data within Parquet files for faster read performance. This is a Fabric-specific optimization that makes queries against your Delta tables significantly faster.

optimizeWrite automatically coalesces small output files into larger ones during writes. This prevents the "small file problem" that degrades query performance.

  • Click the + Code button below the first cell to add a new code cell.
  • Paste the following code to read and transform your CSV data:
from pyspark.sql.functions import col, year, month

# Read the CSV file from the Files section
df = spark.read.option("header", True).option("inferSchema", True).csv("Files/sales_data.csv")

# Cast columns to proper types
df = df.withColumn("OrderDate", col("OrderDate").cast("date")) \
       .withColumn("Revenue", col("Revenue").cast("double")) \
       .withColumn("Quantity", col("Quantity").cast("integer"))

# Add Year and Month partition columns
df = df.withColumn("Year", year(col("OrderDate"))) \
       .withColumn("Month", month(col("OrderDate")))

# Preview the transformed data
display(df)

What does this code do?

The spark.read.csv() call reads your uploaded CSV using a relative path. Because SalesLakehouse is the default lakehouse, Files/sales_data.csv resolves to the Files section automatically.

The withColumn calls cast the inferred string types to proper date, double, and integer types. The year() and month() functions extract partition values from OrderDate.

  • Add one more code cell below Cell 2. Paste the following code to write the Delta table:
# Write the transformed data as a partitioned Delta table
df.write.mode("overwrite") \
  .format("delta") \
  .partitionBy("Year", "Month") \
  .saveAsTable("fact_sales")

What does this code do?

This writes your DataFrame as a managed Delta table named fact_sales in the Lakehouse Tables section. The partitionBy("Year", "Month") organizes the underlying Parquet files into folders by year and month, so queries filtering on dates only scan relevant partitions.

Run the notebook and observe the results

Now you will execute all three cells and watch the Spark session spin up.

  • In the notebook ribbon, select the Run all button on the Home tab.
  • Watch the first cell. Fabric's Live Pool starts a Spark session in seconds. You will see a progress indicator while the session initializes.
  • When Cell 2 finishes, a DataFrame preview appears below the cell showing your transformed data with the new Year and Month columns.
  • When Cell 3 completes, the cell shows a green checkmark and a duration timestamp.

What is Live Pool?

Live Pool is Fabric's default Spark pool for every workspace. It starts in seconds on first cell execution, so you do not need to configure or wait for a dedicated cluster.

Cell stuck on initializing?

If the Spark session takes longer than 60 seconds to start, your trial capacity may be under load. Wait a minute and try Run all again.

If Cell 2 fails with a file-not-found error, confirm your CSV file name matches exactly. In the Lakehouse explorer on the left, expand Files and check the actual file name. Update the path in Cell 2 to match.

help me troubleshoot my notebook cell errors in Microsoft Fabric

Before you verify the table in the Lakehouse, think about what you expect to see. Where should the new table appear in the Lakehouse Explorer?

  • Return to the Lakehouse Explorer by selecting SalesLakehouse in the left panel of the notebook.
  • If the Tables section still appears empty, right-click Tables and select Refresh.
  • Expand the fact_sales table. You should see columns including OrderDate, ProductCategory, Revenue, Year, and Month.
  • Select the fact_sales table name to open a data preview in the main panel. Confirm your rows appear with proper data types and partition values populated.

Table not appearing after refresh?

Make sure all three cells completed without errors. Check the cell output areas for any red error messages.

If you see an error about the table already existing, change mode("overwrite") in Cell 3 to overwrite the previous attempt, then re-run Cell 3.

help me figure out why my Delta table is not appearing in the Lakehouse Explorer

✔️ Awesome, I've got everything!

Great. Make sure you have saved your notebook. Your fact_sales table is now a fully optimized Delta table ready for downstream queries.

ⓧ I'd like to double check the full code

Here is the complete notebook code across all three cells. Confirm each cell in your notebook matches:

Cell 1:

# Enable V-Order optimization for faster reads
spark.conf.set("spark.sql.parquet.vorder.enabled", "true")

# Enable optimizeWrite to reduce small files
spark.conf.set("spark.microsoft.delta.optimizeWrite.enabled", "true")

Cell 2:

from pyspark.sql.functions import col, year, month

# Read the CSV file from the Files section
df = spark.read.option("header", True).option("inferSchema", True).csv("Files/sales_data.csv")

# Cast columns to proper types
df = df.withColumn("OrderDate", col("OrderDate").cast("date")) \
       .withColumn("Revenue", col("Revenue").cast("double")) \
       .withColumn("Quantity", col("Quantity").cast("integer"))

# Add Year and Month partition columns
df = df.withColumn("Year", year(col("OrderDate"))) \
       .withColumn("Month", month(col("OrderDate")))

# Preview the transformed data
display(df)

Cell 3:

# Write the transformed data as a partitioned Delta table
df.write.mode("overwrite") \
  .format("delta") \
  .partitionBy("Year", "Month") \
  .saveAsTable("fact_sales")

Your raw CSV is now a structured, optimized Delta table with date partitions. Next up, you will create an Eventhouse and write KQL queries against this data for real-time analytics.

Create an Eventhouse and Query with KQL

Your fact_sales Delta table is structured, partitioned, and optimized for batch analytics. But the DP-700 exam also tests your ability to query data using KQL for time-series analysis and real-time aggregations.

KQL queries run against data stored in a KQL database, not against Delta Lake tables directly. In this step, you will create an Eventhouse, ingest your transformed data into it, and write KQL queries that aggregate and visualize your sales data.

In this step, get ready to:
  • Create a SalesEventhouse with an automatically generated KQL database.
  • Ingest your fact_sales Delta table into a KQL table named sales_data.
  • Write KQL queries for row counts, category aggregations, and time-series charts.
Create the SalesEventhouse

An Eventhouse is a container for KQL databases in Microsoft Fabric. Creating one also generates a default KQL database with the same name, giving you a ready-to-use query environment.

  • In your project workspace, click New item in the top toolbar.
  • Search for Eventhouse in the item picker.
  • Select Eventhouse from the results.
  • Enter SalesEventhouse as the name.
  • Click Create.

Fabric creates both the Eventhouse and a child KQL database named SalesEventhouse. You should see the Eventhouse landing page with the KQL database listed.

What is an Eventhouse?

An Eventhouse is Microsoft Fabric's home for real-time and time-series analytics. It holds one or more KQL databases, each of which stores data in a columnar format optimized for fast queries.

Think of the Lakehouse as your batch analytics store and the Eventhouse as your fast-query analytics store. The DP-700 exam expects you to know when to use each.

Don't see Eventhouse in the item picker?

Make sure your Fabric trial capacity is active. Eventhouse is part of the Real-Time Intelligence workload, which requires an active capacity.

If you still cannot find it, try searching for Real-Time in the item picker instead.

Help me troubleshoot why Eventhouse is not appearing in my Fabric workspace.

Ingest data from OneLake into the KQL database

Your KQL database is empty. You need to pull the fact_sales data from OneLake into it before you can run any KQL queries.

  • In the SalesEventhouse KQL database view, click Get Data.
  • Select OneLake as the data source.
  • Navigate to your SalesLakehouse and expand Tables.
  • Select the fact_sales table.
  • Set the destination table name to sales_data.
  • Complete the ingestion wizard and wait for the process to finish.

The ingestion may take a minute. Once complete, you should see a confirmation message and the sales_data table listed in your KQL database.

Why not query the Delta table directly with KQL?

KQL databases use their own columnar storage engine optimized for fast scans and time-series operations. They cannot read Delta Lake files directly.

This one-time ingestion copies your data into the KQL engine's format so queries run in milliseconds. In the next step, you will automate this copy with a pipeline.

Ingestion stuck or failed?

Make sure you selected the fact_sales table from the Tables section of your Lakehouse, not the raw CSV in the Files section.

If the ingestion takes more than five minutes, cancel it and try again. Trial capacity can occasionally queue operations.

Help me troubleshoot a failed data ingestion into my KQL database.

Write KQL queries in the embedded queryset

With data in your KQL database, you can now run queries. The Eventhouse includes an embedded KQL queryset where you type and execute queries directly.

  • Open the embedded KQL queryset from your SalesEventhouse KQL database. You should see a query editor with your database connected.
  • Count all rows in your sales data by entering this query:
sales_data | count
  • Click Run or press Shift+Enter to execute the query.

The results grid shows the total number of records. This should match the row count you saw in your Lakehouse table preview.

How does KQL syntax work?

KQL uses a pipe-forward syntax. You start with a table name, then pipe (|) the data through operators that filter, aggregate, or transform it.

Each operator receives the output of the previous one. This makes complex queries readable from left to right, one transformation at a time.

  • Clear the query editor and enter this query to summarize revenue by product category:
sales_data | summarize TotalRevenue=sum(Revenue) by ProductCategory
  • Run the query.

You should see a table with each product category and its total revenue. The summarize operator groups rows and applies an aggregation function to each group.

Now for the most powerful query. Before you run the next one, predict what a "time chart" of daily revenue will look like. Will it be a table or something else?

  • Clear the editor and enter this query to render a time chart of daily revenue:
sales_data | summarize DailyRevenue=sum(Revenue) by bin(OrderDate, 1d) | render timechart
  • Run the query.

Instead of a table, you see a line chart visualization showing daily revenue over time. The render timechart operator tells KQL to display the results as a time-series chart rather than raw rows.

What does bin(OrderDate, 1d) do?

The bin() function rounds each timestamp down to the nearest day (1d). This groups all orders from the same day together before the sum runs.

You can change 1d to 7d for weekly or 1h for hourly buckets. Time binning is a core KQL skill tested on the DP-700 exam.

Query returns no results?

Confirm you are connected to the correct KQL database. The database name should show SalesEventhouse at the top of the queryset.

Check that the table name is sales_data (with an underscore). If you named your table differently during ingestion, use that name instead.

Help me debug why my KQL query returns empty results.

You now have a fully queryable KQL database with three types of queries under your belt: counting, aggregating by category, and time-series visualization. Next up, you will automate the data flow from Lakehouse to Eventhouse with a pipeline so you never have to run a manual ingestion again.

Build a Pipeline to Orchestrate the Flow

Your KQL queries prove the data is queryable in the Eventhouse. But you got that data there by manually using Get Data from the KQL database UI. That manual step does not scale when new sales data lands daily.

The DP-700 exam tests your ability to orchestrate data movement with pipelines. In this step, you will build a Fabric Data Pipeline with a Copy activity that moves data from the Lakehouse Delta table to the KQL database automatically.

In this step, get ready to:
  • Create a SalesPipeline with a Copy activity on the canvas.
  • Configure the Copy activity source and destination connections.
  • Run the pipeline and confirm data flows from Lakehouse to Eventhouse.
Create a new pipeline and add a Copy activity

A pipeline is Fabric's orchestration layer. It coordinates activities like copying data, running notebooks, or triggering dataflows on a schedule.

  • Return to your project workspace in the Fabric portal.
  • Click New item in the top toolbar.
  • Search for Pipeline and select Data pipeline.
  • Name it SalesPipeline and click Create.

The pipeline canvas opens with an empty design surface. This is where you add and connect activities.

  • In the Activities tab on the pipeline canvas toolbar, locate and click Copy data.
  • A Copy activity block appears on the canvas.

What is a Copy activity?

A Copy activity moves data between supported data stores in Fabric. You define a source (where data comes from) and a destination (where data goes). Fabric handles the data transfer, serialization, and error handling.

This is one of the most common pipeline activities tested on the DP-700 exam.

Configure the source and destination connections

The Copy activity needs to know where to read data from and where to write it. You will point the source at your Lakehouse Delta table and the destination at your KQL database.

  • Click on the Copy activity block on the canvas to select it.
  • In the properties pane below the canvas, click the Source tab.
  • Set Connection to Lakehouse.
  • Select SalesLakehouse from the dropdown.
  • Choose the fact_sales table as the source table.

Now configure where the data goes.

  • Click the Destination tab in the same properties pane.
  • Set Connection to KQL Database.
  • Select the SalesEventhouse KQL database from your workspace.
  • Set the destination table to sales_data.

Why KQL Database as the destination?

The Copy activity connector for KQL Database writes directly into your Eventhouse table. This is the same result as the manual Get Data ingestion you did earlier, but now it is repeatable and schedulable.

Don't see KQL Database in the connection list?

Make sure you are in the Destination tab, not the Source tab. The KQL Database option appears in the data store type list on the Destination side.

If the SalesEventhouse database does not appear, confirm it exists in the same workspace as your pipeline.

Still stuck? Help me configure the KQL Database destination for my Copy activity.

Run the pipeline and verify the data transfer

Your pipeline is configured. Time to run it and confirm that data flows from Lakehouse to the Eventhouse KQL database.

  • Click the Home tab in the pipeline ribbon.
  • Click Run.
  • A confirmation dialog appears. Click Save and run.

Before you check the Output tab, predict: do you expect this run to succeed or fail? The source and destination are both in your workspace and you configured them moments ago.

  • Watch the Output tab below the canvas. It shows run progress in real time.
  • Wait until the status shows Succeeded.
  • Note the data read and data written metrics displayed in the Output tab.

What do the Output tab metrics tell you?

The Output tab shows how much data moved (data read and data written) and how long the pipeline took. These metrics help you right-size capacity and troubleshoot slowness on production pipelines.

You can click on the run details button to see a breakdown of copy throughput and duration at a more granular level.

Now confirm the data actually arrived in the KQL database.

  • Return to the KQL queryset you used in the previous step.
  • Run this query to count the rows in the sales_data table:
sales_data | count
  • Confirm the row count matches the number of rows in your fact_sales Lakehouse table.

Row count may be doubled

Because you already ingested data into sales_data manually in the previous step, the pipeline run appended new rows rather than replacing them. If you see double the expected count, that confirms the Copy activity ran successfully. The data arrived twice through two different methods.

Pipeline run failed?

Check that you selected fact_sales as the source table (not the raw CSV file in Files).

Verify the destination table name is sales_data and matches the existing table in your KQL database exactly.

If you see a capacity error, your trial capacity may be temporarily throttled. Wait a minute and try again.

Need more help? My Fabric pipeline Copy activity failed when copying from Lakehouse to KQL Database.

Your data now flows from Lakehouse to Eventhouse through an orchestrated pipeline. This is the pattern the DP-700 exam tests. Next up, you will learn how to monitor these runs and troubleshoot issues using the Fabric Monitoring Hub.

Monitor Your Solution

Your SalesPipeline copies data from Lakehouse to Eventhouse on demand. A working pipeline is only half the story. In production, you need to quickly find failed runs, diagnose bottlenecks, and track execution history.

The Fabric Monitoring Hub gives you a single view of every activity in your workspace. In this step, you will use it to inspect pipeline performance and notebook execution. This maps directly to the DP-700 exam's monitoring and optimization domain.

In this step, get ready to:
  • Open the Monitoring Hub and confirm your pipeline and notebook activities appear.
  • Inspect pipeline run details including duration breakdown and copy throughput.
  • Access pipeline run history from your workspace.
Open the Monitoring Hub and filter by your workspace

The Monitoring Hub shows up to 100 activities from the past 30 days across all Fabric item types. You will filter it down to your workspace to find your specific runs.

  • In the Fabric portal left navigation pane, select Monitor.
  • The Activities page opens showing recent runs across all workspaces.

Before you filter, think about which activities you expect to see. You ran a notebook in Step 2 and a pipeline in Step 4. Both should appear here.

  • Use the workspace filter dropdown to select your project workspace.

You should see two entries: your SalesPipeline run with status Succeeded, and your notebook listed under Spark activities. Both display their start time and duration.

What does the Monitoring Hub show?

The Monitoring Hub tracks every activity that consumes compute in your Fabric capacity. This includes Pipeline runs, Notebook Spark sessions, Lakehouse operations, Dataflow Gen2 refreshes, and more.

Each entry shows the item name, status, start time, duration, and who triggered the run. This is your first stop when diagnosing production issues.

Don't see your activities listed?

  • Check the workspace filter. If it is set to a different workspace, your runs will not appear.
  • Make sure you ran your notebook and pipeline earlier in this session. Activities only appear after execution completes.
  • The Monitoring Hub shows activities from the past 30 days. If your runs are older, they may have aged out.

Why can't I see my pipeline or notebook in the Monitoring Hub?

Inspect the pipeline run detail view

Seeing that a pipeline succeeded is useful, but you also need to understand how long each activity took and how much data moved. The run detail view gives you activity-level performance metrics.

  • Click on the SalesPipeline run name in the Activities list.
  • The run detail view opens showing the pipeline canvas with your Copy activity.

Below the canvas, review the Activity runs list. You should see metrics for data read, data written, and total duration for your Copy activity.

  • Select the Copy activity from the Activity runs list to open the performance details pane.

The performance details pane shows two sections: Duration breakdown and Advanced metrics. The Duration breakdown shows how time was spent across queue, transfer, and other phases. The Advanced metrics display the copy throughput.

Why do duration breakdowns matter?

If a pipeline is slow, you need to know whether the bottleneck is in queuing (waiting for capacity), reading from the source, or writing to the destination. The duration breakdown pinpoints exactly where time is spent.

On the DP-700 exam, you may be asked to diagnose slow pipelines using these metrics. Knowing where to find them is essential.

View run history from the workspace

The Monitoring Hub gives you a cross-workspace view. You can also access a pipeline's run history directly from the workspace. This is faster when you already know which pipeline you want to check.

  • Return to your workspace by selecting it from the left navigation pane.
  • Hover over SalesPipeline in the workspace item list.
  • Select More options (...), then choose View run history.

A fly-out opens showing all recent runs for this pipeline. You should see your successful run listed with its status, start time, and duration.

  • Click Go to monitor to open the full monitoring experience.

This takes you to a detailed monitoring page where you can filter runs by status, time range, and activity type. You now have two ways to reach your pipeline's history: from the Monitoring Hub or directly from the workspace.

When to use each monitoring approach

Use the Monitoring Hub when you need a broad view of all workspace activity, such as finding which items consumed the most capacity. Use the workspace-level run history when you are investigating a specific pipeline's performance over time.

Run history fly-out is empty?

  • Confirm you are hovering over the correct pipeline name. If you renamed it, look for the updated name.
  • Make sure you triggered the pipeline run in Step 4. If the pipeline was only saved but never run, no history exists.

Why is my pipeline run history empty?

You have now explored both monitoring paths in Fabric. You can confirm your pipeline succeeded, inspect how long each phase took, and access run history from either the central Monitoring Hub or the workspace context menu.

Secret mission

Build a Monitoring Dashboard with Workspace Monitoring

Real Fabric Data Engineers go beyond the Monitoring Hub UI. Workspace monitoring writes execution logs to a KQL database you can query programmatically. Enable this preview feature, then write KQL queries against your pipeline execution logs to build a mini monitoring dashboard.

Clean Up Your Resources

Clean Up Your Resources

Decide whether to keep your resources running, pause them to come back later, or delete them entirely.

This project runs entirely on your Fabric free trial capacity (up to 1 TB storage, 60-day trial). No charges apply while the trial is active.

Resources you used:

  • SalesLakehouse (stores Delta tables and CSV files in OneLake, consumes trial capacity storage).
  • SalesEventhouse with KQL database (consumes trial capacity compute for queries).
  • SalesPipeline (consumes capacity units when running).
  • Monitoring Eventhouse (created if you completed the Secret Mission).
  • Notebook (no ongoing cost when not running).

Keep everything running

No action needed. Choose this if you are still actively experimenting with your Fabric workspace during the trial period.

  • All items remain in your workspace and are available for further experimentation.
  • No ongoing charges apply while your 60-day Fabric trial is active.
  • If your trial expires, the workspace becomes read-only until you purchase a capacity or start a new trial.

Pause - I'll come back to this later

Stop any scheduled pipeline runs to free up capacity units. Items remain in your workspace but do not consume compute when idle.

  • If you configured any pipeline scheduling on SalesPipeline, open the pipeline, select the Schedule button on the Home tab, and turn the schedule off.
  • Your Lakehouse, Eventhouse, and Notebook remain in the workspace. They only consume compute when you actively query or run them.

Delete - I don't want to use this again

Remove all project resources at once by deleting the entire workspace. This permanently removes every item inside it.

  • Open your project workspace from the left navigation pane.
  • Select Workspace settings from the toolbar.
  • In the Workspace settings pane, select Other then Remove this workspace.
  • When the warning dialog appears, select Delete to confirm.

What does this remove?

Deleting the workspace permanently removes the SalesLakehouse, SalesEventhouse, SalesPipeline, the Notebook, and any monitoring resources. This action cannot be undone.

Nice Work!

Nice Work!

You just built a complete sales analytics pipeline in Microsoft Fabric that spans all three DP-700 exam domains. Raw data flows in, gets transformed, lands in a queryable store, and the whole process is monitored end to end.

You've learned how to:

  • Ingest raw CSV data into a Lakehouse and transform it with PySpark into optimized Delta tables using V-Order and date partitioning.
  • Create an Eventhouse with a KQL database and write KQL queries for aggregation, time-series analysis, and rendered visualizations.
  • Orchestrate the full data flow with a Fabric pipeline using a Copy activity and monitor runs through the Monitoring Hub with duration breakdowns and status tracking.
  • Secret Mission: Enabled workspace monitoring and queried pipeline execution logs in the ItemJobEventLogs table with KQL to build a mini monitoring dashboard.

Ready to quiz yourself?