Microsoft Fabric Real-Time Dashboard Tutorial | Step-by-Step Guide with Live Examples

Dashboards are the easiest way to keep track of what matters in a business. They bring together numbers, charts, and insights into one place, so you can make better decisions quickly. Power BI dashboards have long been the go-to. And yes, they do support real-time streaming, with several semantic models like push and streaming tiles updating as data flows in. But key point: Microsoft is retiring this real-time streaming feature, and it won’t be possible to create new streaming datasets after October 31, 2027. Microsoft Fabric Real‑Time Dashboards, powered by Real‑Time Intelligence is built for data in motion, live, fast, and flexible. Instead of relying on old streaming models soon to be sunsetted, they offer native support for live data, auto‑refresh, security controls, rich exploration tools, and built‑in alerting, all grounded in a unified Fabric platform.

In simpler terms: Power BI dashboards have been useful for near-real-time updates, but Fabric Real-Time Dashboards let you actually watch your data move in real time, with more power and fewer limitations.

In this post, I’ll first compare Power BI dashboards with Fabric Real-Time Dashboards—with clarity on what’s changing, and then guide you through building your first Real-Time Dashboard inside Microsoft Fabric.

Power BI once let you stream live data. Now Fabric Real-Time Dashboards are taking it further.

Power BI Dashboard

Power BI dashboards have been around for a long time and are still widely used across organisations. They are built on tiles that you pin from reports, Excel, or other sources into a single view. This makes them great for sharing a curated set of KPIs and insights with business users.

You can bring in live or real time data through streaming datasets and push datasets. This allows tiles to update as data flows in, which has been useful for monitoring scenarios like call centre volumes, sales transactions, or IoT sensors.

The challenge is that this real time feature has limitations. It was not designed for high scale or complex event processing, and Microsoft has announced that the old streaming datasets will be retired. That means Power BI dashboards are still valuable for business reporting, but they are no longer the best tool if you need true streaming and operational monitoring at scale.

Microsoft Fabric Real-Time Dashboard

Fabric Real Time Dashboards are a new way of working with data in Microsoft Fabric. Unlike traditional dashboards that heavily rely on refresh cycles, these dashboards are designed to connect directly to streaming data and update instantly.

You can bring data in from Eventstream, KQL Databases, or other live sources inside Fabric. As soon as new events arrive, your visuals respond without needing a manual or scheduled refresh.

The dashboard is built for operational monitoring. You can track live metrics like website clicks, machine performance, financial transactions, or customer activity as they happen. On top of that, you can:

• Customise visuals with conditional formatting so important changes stand out

• Add parameters to interact with the data in real time

• Use the explore feature to quickly query and drill into live streams

• Apply permissions and security controls so the right people see the right view

• Connect to Data Activator for automated actions when thresholds or conditions are met

The big difference is that this is not just a dashboard for reporting history or near real time data. It is designed to watch data in motion and act on it.

Power BI Dashboard vs Fabric Real Time Dashboard

Feature	Power BI Dashboard	Fabric Real Time Dashboard
Data update	Scheduled refresh, DirectQuery, or limited streaming datasets	Instant updates from Eventstream or KQL Database
Use case	Business reporting, monthly/weekly KPIs, curated insights	Operational monitoring, IoT, transactions, live customer activity
Data source	Reports, Excel, Q&A, pinned tiles, push/stream datasets	Native Fabric Real-Time Intelligence sources
Customisation	Themes, pinned visuals, alerts on tiles	Conditional formatting, parameters, rich visual controls
Scalability	Limited for high volume streaming	Built for high scale streaming data
Future support	Streaming datasets retiring in 2027	Actively developed as core part of Fabric

Start with Fabric Real-Time Dashboard

Adding Tiles and Bringing Data

Once you have a Real Time Dashboard created, the next step is to bring data into it by adding tiles. Each tile is a visual connected to a live data source, and it updates automatically as new events arrive.

Sources you can connect to

When you add a tile, you can choose from several sources inside Fabric’s Real-Time Intelligence:

• Eventhouse / KQL Database: the main place for storing and querying live streaming data.

• Azure Data Explorer: external clusters for advanced analytics.

• Application Insights: telemetry from your applications.

• Log Analytics: monitoring data from Azure services.

For most scenarios, and for this demo, we will use Eventhouse / KQL Database.

Example data in our KQL Database

In this walkthrough, I am using two live tables already loaded into my KQL Database:

1. ISSDemo (Click on Link, and read the blog post that explain how to create this free live demo)

   • This table tracks the live location of the International Space Station.

   • Columns include: datetime, latitude, longitude, altitude, velocity, and visibility.

   • The values are updated every few seconds from a public API feed.

2. Taxi

   • This is a public demo dataset of New York City taxi trips availble for free in Fabric

   • Columns include: pickup time, drop-off time, passenger count, trip distance, payment type, and fare amount.

   • It simulates real trip data and is great for testing real-time analytics.

     
     

Step 1. Add a new tile

1. On your dashboard canvas, select Add tile.

2. Choose Eventhouse / KQL Database as the source.

3. Select the database that contains your live tables (for example, ISSDemo and Taxi).

   
   

Step 2. Query the ISSDemo table

The ISSDemo table stores live location details of the International Space Station. It includes columns like datetime, latitude, longitude, altitude, velocity, and visibility.

Here are some simple queries you can use to create different tiles:

Altitude over time (last 15 minutes):

ISSDemo
| project-rename ts = ['datetime']
| where ts > ago(15m)
| summarize AvgAltitude = avg(todouble(altitude)) by bin(ts, 1m)
| order by ts asc

Current average velocity (last 5 minutes):

ISSDemo
| where ['datetime'] > ago(5m)
| summarize AvgVelocity = avg(todouble(velocity))

Latest ISS data (last 10 minutes):

ISSDemo
| where ['datetime'] > ago(10m)
| project ['datetime'], latitude, longitude, altitude, velocity, visibility
| order by ['datetime'] desc

Step 3. Query the Taxi table

The Taxi table is a public demo dataset with live New York City trip details such as pickup and drop-off times, passenger counts, payment types, and fares.

Trips by payment type (last 60 minutes):

Taxi
| where tpep_pickup_datetime > ago(60m)
| summarize Trips = count() by payment_type
| order by Trips desc

Average fare by payment type (last 24 hours):

Taxi
| where tpep_pickup_datetime > ago(24h)
| summarize AvgFare = avg(todouble(total_amount)) by payment_type
| order by AvgFare desc

Recent trips (last 30 minutes):

Taxi
| where tpep_pickup_datetime > ago(30m)
| project tpep_pickup_datetime, passenger_count, trip_distance, payment_type, fare_amount, total_amount
| order by tpep_pickup_datetime desc

Step 4. Save and repeat

Each query can become a separate tile. Add as many as you need from different tables. For example, show ISS altitude in one tile, ISS velocity in another, and Taxi trips by payment type in a third.

Within a few steps, you now have a dashboard pulling live data from multiple sources, updating in real time without refresh.

What Happens When You Run a Query

When you add a tile and paste a KQL query, the first thing you see is always a table of results. This is expected. Every query in Fabric Real-Time Dashboard starts as raw tabular data.

For example, running the altitude query on the ISSDemo table will return rows of timestamp and altitude values. Running the Taxi trips by payment type query will return a simple table with payment type and count.

At this stage, your dashboard looks more like a data explorer than a visual. That is perfectly fine, the power comes when you turn these tables into the right visuals.

Converting Query Results into Visuals

The Real-Time Dashboard gives you several visualisation options. After running your query, you can switch the output from a table into a chart, KPI card, or map. This is where your data comes alive.

Time series (line chart)

For queries that use bin() to group by time, like ISS altitude per minute, choose Time series. This shows a clear line moving up and down as new values stream in.

Stat or KPI card

For queries that return a single number, like average velocity, switch to Stat. This will give you a clean card showing the number. You can later add conditional formatting to highlight it when it goes above or below thresholds.

Column or bar chart

For grouped results like Taxi trips by payment type, pick Column or Bar chart. This makes it easy to compare categories and see which one leads.

Table

Sometimes the raw detail is valuable. Queries that project fields such as Taxi passenger count, trip distance, and fare can stay as a Table. Tables update in real time and give a scrolling list of fresh events.

Map (for ISS location)

One of the most powerful options is the Map visual. Since the ISSDemo table has latitude and longitude columns, you can plot the space station’s path across the Earth in real time.

Example query for mapping ISS position:

ISSDemo
| where ['datetime'] between (ago(10m) .. now())
| project ts = ['datetime'], latitude, longitude, altitude
| order by ts desc

Results in Table after running a query

When you run this query, you will first see the results in a table with three columns: timestamp, latitude, and longitude. To turn this into a map:

1. Look to the right of the query results and click on Add visual.

2. Set name for this Tile and add description if required

3. From the list of Visual type, select Map.

4. In the Data section, set Define Location by to Latitude and Longitude 

5. Then set Latitude to the latitude column and Longitude to the longitude column.

6. Optionally, set Size to the altitude column so you can see changes in height visually.

7. Save the tile.

Now your dashboard shows a real-time map of the ISS orbiting Earth. As new data comes in, the dot moves automatically without you needing to refresh.

ISS location on Fabric Real-Time Dashboard - Map visual

Add a KPI visual and apply conditional formatting

Now let's create a single-value KPI from the Taxi table, then make it change colour when it crosses a threshold. You can choose any metric. Two good options are Trips per minute or Average fare.

Option A. Trips per minute (last 5 minutes)

Taxi
| where tpep_pickup_datetime > ago(5m)
| summarize TripsPerMin = count() * 1.0 / 5.0

Option B. Average fare (last 15 minutes)

Taxi
| where tpep_pickup_datetime > ago(15m)
| summarize AvgFare = avg(todouble(total_amount))

Add a new Page in Fabric Real-Time Dashboard

You can add many pages in Fabric Real-Time Dashboard. Click on pages ribbon at left, change the current page name to ISS, and then at botton click on Add page and name that Taxi.

Add the KPI tile - use Taxi sample data

The Taxi table is a live source in Fabric, but the rows were recorded years ago. That means a filter like “last 5 minutes from now” may return nothing. To make the dashboard reliable, we anchor our queries to the latest timestamp inside the table, then look back from there.

We will:

1. Build a Top N tile that always has data

2. Add a Total trips in last 24 hours card

3. Add an Average trips per day in last week card

4. Add a comparison KPI that turns green when last 24 hours is above the weekly average

All Taxi columns are text, so we cast types inside each query.

Query for Total Trips and Average Trips per Day

Here’s a single query that gives you both numbers in 3 rows and 2 columns. We also calculate a simple ratio so we can compare them in a KPI later.

Step 1. Add the query as a tile

1. Click Add tile → choose KQL Database.

2. Paste in the query above and run it.

3. At first you’ll see a small table with 2 columns and 3 rows

   
   

// 1) Anchor to the most recent timestamp in the table

let LastTs =

toscalar(

Taxi

| extend ts = todatetime(tostring(tpep_pickup_datetime))

| where isnotnull(ts)

| summarize max(ts)

);

// 2) Compute totals and averages as scalars

let TripsLast24h =

toscalar(

Taxi

| extend ts = todatetime(tostring(tpep_pickup_datetime))

| where isnotnull(ts) and ts between (LastTs - 24h .. LastTs)

| summarize count()

);

let AvgTripsPerDayLastWeek =

toscalar(

Taxi

| extend ts = todatetime(tostring(tpep_pickup_datetime))

| where isnotnull(ts) and ts between (LastTs - 7d .. LastTs)

| summarize Trips = count() by bin(ts, 1d)

| summarize avg(Trips)

);

// 3) Build Title/Result rows

print

TripsLast24h = todouble(TripsLast24h),

AvgTripsPerDayLastWeek = todouble(AvgTripsPerDayLastWeek),

Ratio = iif(AvgTripsPerDayLastWeek > 0,

todouble(TripsLast24h) / todouble(AvgTripsPerDayLastWeek),

real(null))

| project

Titles = pack_array("TripsLast24h", "AvgTripsPerDayLastWeek", "Ratio"),

Results = pack_array(TripsLast24h, AvgTripsPerDayLastWeek, Ratio)

| mv-expand Title = Titles to typeof(string),

Result = Results to typeof(double)

| project Title, Result

Query Result - Last 24 hours vs Avg per day last week

Step 2. Show both KPIs side by side

1. Change the visual type to Multi-stat.

2. Change the layout to 1 column and 3 rows

3. Set Lable as Title and Value as Result

4. Rename the KPIs clearly, for example Trips (24h) and Avg Trips/Day (7d).

5. Save the tile.

Now your dashboard shows both KPIs updating together.

Step 3. Set conditional formatting on Stat

The Ratio tells you how the last 24 hours compares to the daily average of the last week.

• 1.0 means exactly average.

• Greater than 1.0 means above average.

• Less than 1.0 means below average.

• Create another tile with the same query (or duplicate the first tile).

• Change the visual type to Stat.

• Bind the value to Ratio.

Add conditional formatting:

• Green if Ratio ≥ 1.0

• Amber if 0.9 to 0.99

• Red if < 0.9

How to set Stat with Conditional Formatting in Fabric Real-Time Dashboard

This way, the card will immediately turn green if the last 24 hours of trips are higher than the weekly daily average, or red if they are below.

Output:

Output of cards

Adding Parameters to Your Real-Time Dashboard

Parameters make your dashboard interactive. Instead of editing queries every time you want a new filter or time window, you can add controls that the dashboard user can change on the fly.

Adding a Parameter for ISS Map

Step 1. Create the parameter

1. On the dashboard, click New Parameter.

2. Fill the form as follows:

   • Label: TimeRangeMinutes

   • Parameter type: Single selection

   • Variable name: TimeRangeMinutes

   • Data type: string (we’ll cast it later in the query)

   • Show on pages: Select all

   • Source: Fixed values

   • Add values like:

     • Value = 10, Label = “Last 10 minutes”

     • Value = 30, Label = “Last 30 minutes”

     • Value = 60, Label = “Last 60 minutes”

   • Default value: 10

How to set a new parameter in Fabric Real-Time Dashboard

1. Click Done.You now have a dropdown on the dashboard that controls TimeRangeMinutes.

   
   

Step 2. Update the ISS Map query

Original query (fixed 10 minutes):

ISSDemo
| where ['datetime'] between (ago(10m) .. now())
| project ts = ['datetime'], latitude, longitude, altitude
| order by ts desc

Updated query with parameter:

ISSDemo
| extend ts = todatetime(tostring(['datetime']))
| where isnotnull(ts) and ts between (ago(toint(TimeRangeMinutes) * 1m) .. now())
| project ts, latitude, longitude, altitude
| order by ts desc

Notice we cast the parameter to an integer with toint() because parameters arrive as text.

Step 3. Save and test

• Edit your ISS Map tile and replace the query with the updated version.

• Save the tile.

• Now use the parameter dropdown on the dashboard to switch between 10, 30, or 60 minutes of ISS orbit. The map updates instantly.

Trigger the Alert

Real-time dashboards aren’t just about watching data, they can take action. By connecting to Data Activator, you can set up rules that trigger alerts when certain conditions are met.

Example:

• In your Taxi KPI, if the TripsLast24h suddenly drops below 50% of the weekly average.

• In your ISS dashboard, if velocity goes above a threshold.

How to create an alert:

1. Hover over your KPI tile (e.g. the Ratio Stat).

2. Select Alert icon and click on it

3. Define your condition:

   • Example: If Ratio < 0.9 for 5 minutes, then send a Teams message.

   • Example: If ISS velocity > 27,580 for 2 minutes, then send an email.

4. Pick your action: Teams, email, or Run a Fabric Item.

5. Save and let it run.

Now your dashboard doesn’t just monitor events; it reacts to them.

Why This is Better for Live Operations than a Traditional Dashboard

Traditional dashboards, like Power BI, are fantastic for reporting and analysis , but they rely on scheduled refreshes or manual updates. That works well for daily, weekly, or even hourly KPIs, but it falls short in real-time operational scenarios.

With Fabric’s Real-Time Dashboards, you get:

• Instant updates: visuals refresh as soon as new events arrive.

• Operational focus: built to watch streams of events, not just historical data.

• Interactivity at speed: parameters, cross-filtering, and drillthrough keep up with live data without breaking context.

• Action, not just insight: alerts through Data Activator mean your team is notified immediately when conditions are met.

Think of it this way:

• A Power BI dashboard is like a daily news article, polished, insightful, but slightly behind.

• A Real-Time Dashboard is like a live news ticker, constantly updating, alerting you the moment something changes.

For operations teams, call centres, monitoring centres, or IoT scenarios, that difference is critical.

Closing Thoughts

Fabric Real-Time Dashboards give you a new way of working with data. Instead of only reporting what already happened, they let you respond to what is happening right now. Whether you are tracking the ISS orbit, monitoring live transactions, or watching IoT events, the difference between a refresh-based dashboard and a live one is clear and powerful.

Try building your own Real-Time Dashboard today. Start with a simple dataset, add a map or KPI card, and then layer in parameters, cross-filtering, and alerts. You will quickly see why this is a game changer for live operations compared to traditional dashboards.