Telecom Network Dashboard with Power BI

Generate telecom KPI data with Python and build an AI-powered Power BI dashboard.

Introduction

30 Second Summary

Every time a video call freezes or a download crawls, someone at a telecom company needs to figure out why. Spotting the symptom is straightforward, but tracing it to the exact cell tower, weather event, or maintenance window responsible is the real challenge.

In this project, you will write a Python script that generates realistic cell tower performance data. Then you will import that data into Power BI and build an interactive dashboard that uses AI to automatically surface the root causes of network issues.

What You'll Build

You will run a single command to generate fresh network data, then open a dashboard that tells you which towers are underperforming and exactly why.

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

  • A Python script you can run with one command to generate a fresh CSV dataset with thousands of rows of realistic network data, complete with hidden patterns for AI to discover.
  • A multi-page Power BI dashboard where you can ask "what drives high packet loss?" and get a statistically-backed answer, then drill down from region to tower to root cause.
  • Smart Narratives and Anomaly Detection features that auto-generate plain English summaries and flag unusual throughput dips for stakeholders.
  • Secret Mission: embed a Python-powered forecast visual inside Power BI that predicts network throughput trends using linear regression.

Are there any prerequisites?

This project assumes basic Python experience with variables, loops, and functions. You will need Python and Power BI Desktop (a free Windows application) installed on your machine.

Before We Start

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

Set Up Your Python Environment

Python and Power BI Desktop are already on your machine. Before you can generate telecom data or create Python-powered charts inside Power BI, you need two additional libraries that do not come bundled with Python.

pandas handles data creation and CSV export. matplotlib powers the charting engine that Power BI uses for Python visuals. In this step, you will install both libraries and set up a dedicated project folder.

In this step, get ready to:
  • Install the pandas and matplotlib libraries.
  • Verify the installation works by printing the pandas version.
  • Create a project folder for your dashboard files.
Install the required Python libraries
  • Press Cmd+Space (macOS) or the Windows key (Windows) to open your search bar.
  • Type Terminal (macOS) or PowerShell (Windows) and press Enter to open it.
  • Install pandas and matplotlib by running this command:
pip install pandas matplotlib

You should see output ending with a line that starts with Successfully installed followed by the package names and version numbers.

Seeing 'pip: command not found'?

  • Try pip3 instead of pip. Some systems use pip3 to point to the Python 3 package manager.
  • If neither works, run python -m pip install pandas matplotlib to call pip through Python directly.
  • Why can't my terminal find pip?
Verify the installation

Before you run the next command, what do you expect to see if both libraries installed correctly?

  • Verify both libraries are importable by running this command:
python -c "import pandas; import matplotlib; print(pandas.__version__)"

You should see a version number like 3.0.5 printed with no errors. This confirms both pandas and matplotlib are installed and Python can find them.

Seeing ModuleNotFoundError?

If you see ModuleNotFoundError: No module named 'pandas', pip may have installed the packages for a different Python version than the one you are running.

  • Check which Python you are using by running python --version. Make sure it says 3.14.4.
  • If the version is different, try reinstalling with python -m pip install pandas matplotlib to ensure pip targets the correct Python.
  • Why is my Python import failing even though pip said it installed successfully?
Create your project folder

Your libraries are ready. Now you need a dedicated folder to hold your Python script and the data it generates.

  • Move to your Desktop by running this command:
cd ~/Desktop
  • Create your project folder and move into it by running these commands:
mkdir telecom-dashboard
cd telecom-dashboard
  • Confirm you are inside the new folder by running:
ls

The output should be empty because the folder is brand new. That is expected. You will add your Python script here in the next step.

Getting an error with cd ~/Desktop?

  • If you are using Command Prompt on Windows, ~ is not recognized. Use cd %USERPROFILE%\Desktop instead, or switch to PowerShell where ~ works.
  • If you see mkdir: cannot create directory, a folder called telecom-dashboard may already exist. Delete it first or choose a different name.
  • I cannot create my project folder on the Desktop. What should I try?

Your environment is ready. You have pandas for data creation, matplotlib for charting, and a clean project folder waiting for code. Next up, you will write a Python script that generates thousands of rows of realistic telecom network data.

Generate Telecom Network Data with Python

Your pandas and matplotlib libraries are installed, and your project folder is ready. Now you need data to feed into your dashboard.

Instead of downloading a generic dataset, you will write a Python script that generates realistic telecom network KPI data. This is the business-to-digital translation skill: you are encoding what real network data looks like (throughput, latency, packet loss across cell towers) into a repeatable, automated script.

In this step, get ready to:
  • Create a Python script that generates 6 months of daily telecom network KPI data across 4 regions.
  • Embed hidden patterns (storms, outages, technology differences) that AI visuals can discover later.
  • Run the script and verify the CSV output file.
Create the script and define your network configuration

Your script needs to know what a telecom network looks like: regions, cell towers, technology types, weather conditions, and maintenance statuses. This configuration block defines the entire data model your generation loop will use.

  • Create a new file called generate_network_data.py inside your telecom-dashboard folder by running this command:
touch generate_network_data.py
  • Confirm the file was created by running:
ls

You should see generate_network_data.py listed in the output.

  • Open generate_network_data.py in a text editor and paste the following configuration code:
import pandas as pd
import random
from datetime import datetime, timedelta

# Fixed seed so data is identical every time you run
random.seed(42)

# Network topology: 4 regions, 3 cell towers each
regions = ["North", "South", "East", "West"]
towers_per_region = {
    "North": ["TOWER-N01", "TOWER-N02", "TOWER-N03"],
    "South": ["TOWER-S01", "TOWER-S02", "TOWER-S03"],
    "East": ["TOWER-E01", "TOWER-E02", "TOWER-E03"],
    "West": ["TOWER-W01", "TOWER-W02", "TOWER-W03"],
}
technologies = ["4G", "5G"]
weather_conditions = ["Clear", "Rain", "Storm"]
weather_weights = [0.6, 0.3, 0.1]
maintenance_statuses = ["Normal", "Scheduled", "Emergency"]
maintenance_weights = [0.85, 0.10, 0.05]

# 6 months of daily data (Jan-Jun 2026)
start_date = datetime(2026, 1, 1)
end_date = datetime(2026, 6, 30)
num_days = (end_date - start_date).days + 1

# Hidden outage for AI visuals to discover later
outage_tower = "TOWER-S03"
outage_start = datetime(2026, 3, 15)
outage_end = datetime(2026, 3, 28)

What does this code do?

This block defines the entire shape of your dataset before any data is generated.

  • random.seed(42) locks the random number generator so you get the same data every time you run the script. This makes your results reproducible.
  • towers_per_region maps 4 regions to 3 cell towers each (12 towers total), mimicking a real telecom network layout.
  • weather_weights and maintenance_weights control how often each condition appears. Storms are rare (10%), and emergency maintenance is uncommon (5%).
  • outage_tower sets up a hidden pattern: TOWER-S03 will have a 2-week outage that Power BI's AI visuals should be able to discover on their own.
  • Save generate_network_data.py.
Build the data generation loop

The loop iterates over every day and every tower, generating one row of KPI data per tower per day. Each row gets a random technology assignment and base performance values that differ between 4G and 5G.

  • In generate_network_data.py, add the following code below your configuration block:
rows = []

for day_offset in range(num_days):
    current_date = start_date + timedelta(days=day_offset)
    date_str = current_date.strftime("%Y-%m-%d")

    for region in regions:
        for tower_id in towers_per_region[region]:
            # Randomly assign technology and conditions
            tech = random.choice(technologies)

            weather = random.choices(
                weather_conditions, weights=weather_weights, k=1
            )[0]
            maint = random.choices(
                maintenance_statuses, weights=maintenance_weights, k=1
            )[0]

            # 5G towers get higher throughput, slightly higher latency
            if tech == "5G":
                base_throughput = random.uniform(150, 300)
                base_latency = random.uniform(15, 35)
            else:
                base_throughput = random.uniform(50, 150)
                base_latency = random.uniform(20, 50)

            base_packet_loss = random.uniform(0.1, 1.0)
            base_uptime = random.uniform(97, 99.9)
            active_users = random.randint(200, 2000)

What does this code do?

  • The triple-nested loop (days, regions, towers) creates one data row for every tower on every day. With 181 days and 12 towers, that is 2,172 rows total.
  • random.choices() picks weather and maintenance using the weighted probabilities you defined earlier. Storms appear roughly 10% of the time.
  • 5G towers start with throughput between 150-300 Mbps while 4G towers start between 50-150 Mbps. This mirrors real-world technology differences.

This loop generates base values, but real network data has patterns. Weather degrades performance. Maintenance windows reduce capacity. The next code block adds those effects.

  • Add the following code directly below the active_users line, keeping the same indentation level (inside the for tower_id loop):
            # Weather effects: storms degrade performance significantly
            if weather == "Rain":
                base_latency *= 1.15
                base_packet_loss *= 1.5
                base_throughput *= 0.9
            elif weather == "Storm":
                base_latency *= random.uniform(1.3, 1.5)
                base_packet_loss *= random.uniform(2.0, 3.0)
                base_throughput *= 0.7
                base_uptime -= random.uniform(2, 5)

            # Maintenance windows reduce tower capacity
            if maint == "Scheduled":
                base_uptime -= random.uniform(1, 3)
                base_throughput *= 0.85
            elif maint == "Emergency":
                base_uptime -= random.uniform(5, 10)
                base_throughput *= 0.6
                base_packet_loss *= 2.0

Why embed these patterns?

These are the hidden signals that Power BI's AI visuals will discover later. Storms increase latency by 30-50% and packet loss by 2-3x. Emergency maintenance cuts throughput by 40% and doubles packet loss.

When you build the Key Influencers visual in Step 4, it will statistically rank these factors without you telling it what to look for. The patterns have to be real enough for machine learning to detect.

  • Save generate_network_data.py.
Simulate the tower outage, build each row, and export

The last piece of the loop simulates a specific tower outage, clamps all values to realistic ranges, builds each data row, and exports the full dataset to a CSV file.

  • Add the following code directly below the emergency maintenance block you just pasted, keeping the same indentation level:
            # Hidden outage: TOWER-S03 degrades severely for 2 weeks
            if tower_id == outage_tower and outage_start <= current_date <= outage_end:
                base_uptime = random.uniform(60, 70)
                base_throughput *= 0.3
                base_packet_loss = random.uniform(5, 10)
                base_latency *= 2.5
                maint = "Emergency"

            # Clamp values to realistic ranges
            base_uptime = max(0, min(100, base_uptime))
            base_packet_loss = max(0, min(15, base_packet_loss))
            base_latency = max(5, base_latency)
            base_throughput = max(10, base_throughput)

            rows.append({
                "Date": date_str,
                "Region": region,
                "Tower_ID": tower_id,
                "Technology": tech,
                "Throughput_Mbps": round(base_throughput, 2),
                "Latency_ms": round(base_latency, 2),
                "Packet_Loss_Pct": round(base_packet_loss, 2),
                "Uptime_Pct": round(base_uptime, 2),
                "Active_Users": active_users,
                "Weather": weather,
                "Maintenance_Status": maint,
            })

# Convert all rows to a DataFrame and export
df = pd.DataFrame(rows)
df.to_csv("network_kpi_data.csv", index=False)
print(f"Generated {len(df):,} rows of network data. Saved to network_kpi_data.csv")

What does this code do?

  • The outage block overrides TOWER-S03's values during March 15-28: uptime drops to 60-70%, throughput falls to 30% of normal, and packet loss jumps to 5-10%. This is the "sudden outage" that Power BI's Decomposition Tree should trace.
  • The clamping lines use max() and min() to keep values within realistic bounds (e.g. uptime between 0-100%, latency at least 5ms).
  • rows.append() builds a dictionary for each data row with all 11 columns. After the loop finishes, pd.DataFrame(rows) converts the list into a pandas DataFrame and exports it to CSV.
  • Save generate_network_data.py.

Before you run the script, what do you think the output will tell you? How many rows should 181 days of data across 12 towers produce?

  • Run the script by executing this command in your terminal:
python generate_network_data.py

You should see Generated 2,172 rows of network data. Saved to network_kpi_data.csv printed in your terminal. That is 181 days multiplied by 12 towers.

  • Confirm the CSV file was created by running:
ls

You should now see both generate_network_data.py and network_kpi_data.csv in the output.

Seeing an error when you run the script?

  • If you see IndentationError, check that the weather effects, maintenance effects, outage block, clamping lines, and rows.append() are all indented with 12 spaces (three levels deep inside the triple-nested loop). The last three lines (df = ..., df.to_csv(), and print()) should have zero indentation because they run after the loop finishes.
  • If you see ModuleNotFoundError: No module named 'pandas', make sure you installed pandas in the previous step. Run pip install pandas and try again.
  • If you see SyntaxError, check for missing commas inside the rows.append({}) dictionary or mismatched quotes in the string values.

Help me debug my generate_network_data.py script

Now spot-check a few rows to make sure the data looks realistic.

  • Preview the first 5 rows of your dataset by running this command:
python -c "import pandas as pd; df = pd.read_csv('network_kpi_data.csv'); print(df.head())"

You should see a table with columns like Date, Region, Tower_ID, and Throughput_Mbps. Throughput values should be in the 50-300 Mbps range, latency in the 10-80ms range, and packet loss between 0-5% for most rows.

Why generate data instead of downloading a dataset?

Writing the generation script yourself demonstrates two skills the internship requires: scripting/automation and business-to-digital translation. You translated what real network data looks like into code.

You also control exactly which patterns exist in the data, so the AI visuals in Power BI will have meaningful insights to surface. A random downloaded dataset might not contain any discoverable patterns at all.

✔️ Awesome, I've got everything!

Great. Double check you have saved generate_network_data.py and that network_kpi_data.csv exists in your telecom-dashboard folder.

ⓧ I'd like to double check the full code

Your generate_network_data.py file should contain these four sections in order. Scroll up and confirm each one is present:

  • Configuration block: imports, random.seed(42), regions, towers, technologies, weather/maintenance lists with weights, date range, and outage tower variables.
  • Generation loop: triple-nested for loop (days, regions, towers) with random technology/weather/maintenance assignments and base KPI values that differ for 4G vs 5G.
  • Pattern effects: weather degradation (Rain and Storm), maintenance capacity reduction (Scheduled and Emergency), TOWER-S03 outage override, value clamping, and rows.append() with all 11 columns.
  • Export block: pd.DataFrame(rows), df.to_csv(), and the print() line at the bottom with zero indentation.

You now have a complete dataset with hidden patterns waiting to be discovered. Next up, you will import this CSV into Power BI and build your first dashboard visuals to see what the data reveals at a glance.

Build the Base Dashboard in Power BI

Your Python script generated a CSV with thousands of rows of realistic network performance data. Numbers in a spreadsheet don't tell a story though. You need charts and KPIs that reveal patterns at a glance.

In this step, you'll load your data into Power BI Desktop and build an interactive dashboard with trend lines, regional comparisons, and key metric cards. By the end, you'll also discover an important limitation of basic visuals.

In this step, get ready to:
  • Import network_kpi_data.csv into Power BI and verify column data types.
  • Build a line chart, bar chart, KPI cards, and a region slicer on the canvas.
  • Test your dashboard's limits by trying to answer a "why" question about network issues.
Load your CSV data into Power BI

Before you can build any visuals, you need to import your CSV into Power BI Desktop and make sure every column has the right data type.

  • Press the Windows key to open your search bar.
  • Type Power BI Desktop and press Enter to open it.
  • On the Home ribbon, click Get Data.
  • Select Text/CSV from the list.
  • Navigate to the telecom-dashboard folder on your Desktop.
  • Select network_kpi_data.csv and click Open.

A preview of your data appears, showing the columns and sample rows.

  • Click Transform Data to open the Power Query Editor.

What is Power Query?

Power Query is Power BI's built-in data preparation tool. It lets you clean, reshape, and set data types before the data reaches your report canvas.

Getting data types right here matters. If Power BI thinks your Date column is text, your time-based charts won't work correctly.

  • In the Power Query Editor, look at the small icons next to each column header. These icons indicate the column's data type.
  • Confirm Date shows a calendar icon (Date type). If it shows ABC (Text), click the icon and select Date.
  • Confirm Throughput_Mbps, Latency_ms, Packet_Loss_Pct, and Uptime_Pct are set to Decimal Number.
  • Confirm Active_Users is set to Whole Number.
  • Confirm Region, Tower_ID, Technology, Weather, and Maintenance_Status are set to Text (shown as ABC).
  • On the Home ribbon, click Close & Apply.

Power BI loads the data and returns you to the report canvas. You should see network_kpi_data listed in the Data pane on the right side, with all 11 columns visible underneath it.

Don't see your data in the Data pane?

  • Make sure you clicked Close & Apply, not just Close. Closing without applying discards your data type changes and doesn't load the data.
  • If Power BI shows a loading error, check that network_kpi_data.csv is still in your telecom-dashboard folder. Power BI reads the file from its original location.

Help me load my CSV into Power BI Desktop.

Build the overview visuals

With your data loaded, it's time to turn numbers into visuals. You'll create five visuals on the canvas: a line chart, a bar chart, two KPI cards, and a region slicer.

  • Click an empty area on the report canvas.
  • In the Visualizations pane on the right, click the Line chart icon.
  • From the Data pane, drag Date into the X-axis well.
  • Drag Throughput_Mbps into the Y-axis well.
  • Power BI defaults to summing the values. Click the dropdown arrow next to Throughput_Mbps in the Y-axis well and select Average.

A line chart appears on the canvas showing average throughput over time. You should see the trend line with some visible dips, especially around March 2026.

  • Click an empty area on the canvas (away from the line chart).
  • Select the Clustered bar chart icon from the Visualizations pane.
  • Drag Region into the Y-axis well.
  • Drag Packet_Loss_Pct into the X-axis well.
  • Click the dropdown arrow next to Packet_Loss_Pct in the X-axis well and select Average.

Your canvas now shows two charts. The bar chart compares average packet loss across the four regions.

Chart showing a single bar or no data?

  • Make sure you dragged Region to the Y-axis well, not the X-axis well. Swapping the wells produces a column chart instead of the horizontal bar chart.
  • If you see Sum instead of Average next to the field name in the well, click the dropdown arrow and change it to Average.

Help me build my charts in Power BI.

  • Click an empty area on the canvas.
  • Select the Card visual from the Visualizations pane.
  • Drag Latency_ms into the Values field well.
  • Click the dropdown arrow next to Latency_ms and select Average.
  • Click an empty area on the canvas.
  • Select another Card visual from the Visualizations pane.
  • Drag Uptime_Pct into the Values field well.
  • Click the dropdown arrow next to Uptime_Pct and select Average.

Two card visuals now display single numbers on the canvas: average latency in milliseconds and average uptime as a percentage.

  • Click an empty area on the canvas.
  • Select the Slicer visual from the Visualizations pane.
  • Drag Region into the Field well.

A slicer appears showing the four regions (North, South, East, West) as clickable filter options.

Cards showing a sum instead of an average?

  • Power BI defaults every numeric field to Sum. For each card, click the dropdown arrow next to the field name in the Values well and change it to Average.
  • If you don't see the dropdown arrow, make sure the card visual is selected (click on it) before looking at the Visualizations pane.

Help me set up my KPI cards and slicer in Power BI.

Test the dashboard by filtering

Your dashboard is built. Before moving on, test whether it can answer a real business question.

  • Before you click anything, predict: what do you think will happen to the other visuals when you click a region in the slicer?
  • Click South in the Region slicer.

All your visuals update instantly to show only the South region's data. The line chart, bar chart, and both cards filter down to South. This cross-filtering is one of Power BI's most powerful features.

Now try to answer this question using only your dashboard: what is causing packet loss to spike in certain regions? Is it weather? Is it maintenance? Is it a specific tower?

You can see that some regions have higher packet loss than others. You can see throughput dipping at certain times. But you cannot tell why from these basic visuals alone. The charts show the symptom, not the cause.

Why can't basic visuals answer "why" questions?

Line charts and bar charts show trends and comparisons, but they don't reveal which factors drive those patterns. To answer "what causes high packet loss," you'd need to test every combination of weather, maintenance status, tower, and technology manually.

This is exactly the gap that AI visuals like Key Influencers and Decomposition Tree are designed to fill. They use machine learning to find the factors that matter most, automatically.

  • Click the active South button in the slicer to deselect it and restore the full view of all regions.

Your base dashboard shows the what. Next up, you'll add AI-powered visuals that reveal the why.

Uncover Root Causes with AI Visuals

In the last step, you built a dashboard that shows network performance at a glance. You could see which regions have higher packet loss and when throughput dips. But when you tried to answer "why is packet loss spiking in certain regions?", the basic charts could only show the symptom, not the cause.

Power BI's AI visuals close that gap. In this step, you will add a Key Influencers visual that uses machine learning to statistically rank which factors drive packet loss. You will also add a Decomposition Tree that lets you drill down through multiple dimensions to trace issues to their root cause.

In this step, get ready to:
  • Add a Key Influencers visual to statistically identify what drives packet loss.
  • Add a Decomposition Tree to drill down from region to tower to root cause.
  • Create a DAX measure that shows the percentage of towers falling below the uptime target.
Add a Key Influencers visual

The Key Influencers visual runs a decision tree algorithm on your data and ranks which factors most strongly influence a metric you choose. Instead of manually comparing charts, you let Power BI find the statistical answer.

  • Click the + icon at the bottom of the report canvas to create a new page.
  • In the Visualizations pane under Build visual, select the Key influencers icon.
  • Drag Packet_Loss_Pct from the Data pane into the Analyze field well.
  • Drag Weather into the Explain by field well.
  • Drag Region into the Explain by field well.
  • Drag Technology into the Explain by field well.
  • Drag Maintenance_Status into the Explain by field well.
  • Drag Tower_ID into the Explain by field well.

Before you look at the results, think about this: what do you think is the biggest factor driving high packet loss? Weather? A specific tower? The technology type?

Power BI runs its analysis and displays the top influencers on the left side of the visual. You should see Weather being Storm and Maintenance_Status being Emergency ranked as the top factors increasing packet loss.

What does Key Influencers tell you?

The visual uses an ML.NET decision tree to find which values in your data most strongly correlate with higher packet loss. It shows the result as a multiplier. For example, "when Weather is Storm, packet loss increases by 2.5x."

The adjacent chart on the right updates when you click an influencer, showing the comparison distribution. This is the statistical proof your basic bar chart could not provide.

Not seeing any influencers?

Make sure you dragged Packet_Loss_Pct into the Analyze field well, not Explain by. The metric to investigate goes in Analyze. The potential causes go in Explain by.

If the visual says it needs more data, resize it larger on the canvas. AI visuals need enough space to render their full results.

Help me troubleshoot my Key Influencers visual in Power BI.

Add a Decomposition Tree visual

Key Influencers tells you which factors matter most overall. The Decomposition Tree lets you drill down step by step through those factors to trace a specific issue to its root cause.

  • Click an empty area of Page 2 so no existing visual is selected.
  • In the Visualizations pane under Build visual, select the Decomposition tree icon.
  • Drag Packet_Loss_Pct into the Analyze field well.
  • Drag Region, Tower_ID, Weather, Technology, and Maintenance_Status one by one into the Explain by field well.

The Decomposition Tree shows the overall average packet loss as the root node with a + sign next to it.

  • Click the + next to the root node.
  • Select High value from the dropdown. Power BI's AI picks the dimension that leads to the highest packet loss.
  • Keep clicking the + on the newly expanded nodes and selecting High value each time to drill deeper.

Follow the AI's drill-down path. You should be able to trace high packet loss from a specific region down to TOWER-S03. That is the tower with the embedded two-week outage you built into the Python script.

How does the AI pick the next dimension?

When you select High value, Power BI analyzes all the dimensions in the Explain by field well and picks the one that leads to the highest value of the metric. The AI-suggested splits appear with a light bulb icon next to them.

You can also manually pick a dimension instead of using the AI suggestion. This lets you explore your own hypotheses alongside the AI-driven path.

Tree not expanding?

Make sure you added at least one field to the Explain by field well. If the + icon does not appear, try resizing the Decomposition Tree visual to give it more space on the canvas.

Help me troubleshoot my Decomposition Tree visual.

Create a DAX measure for below-target uptime

AI visuals reveal patterns, but stakeholders also need a single number they can track at a glance. A DAX measure lets you create a custom calculation that summarizes how often towers fall below the 95% uptime target.

  • In the Data pane on the right, right-click the network_kpi_data table.
  • Select New Measure.
  • Type the following DAX formula in the formula bar that appears at the top of the canvas:
Below Target Uptime = DIVIDE(COUNTROWS(FILTER(network_kpi_data, network_kpi_data[Uptime_Pct] < 95)), COUNTROWS(network_kpi_data))

What does this measure calculate?

This formula counts every row in network_kpi_data where Uptime_Pct is below 95%, then divides that by the total row count. The result is the fraction of data points where towers missed the uptime target.

DIVIDE is a safe division function that returns 0 instead of an error if the denominator is zero.

  • Press Enter to confirm the formula.
  • With the new measure selected in the Data pane, go to the Measure tools tab in the ribbon.
  • Click the Format dropdown and select Percentage.
  • Click an empty area of Page 2 so no existing visual is selected.
  • In the Visualizations pane, select the Card visual.
  • Drag the Below Target Uptime measure into the Card's field well.

Your Card now displays a single percentage showing how often towers fall below 95% uptime across the entire dataset. This gives stakeholders one number that captures overall network health.

Seeing an error in the formula bar?

Check that you typed the table name network_kpi_data exactly as it appears in your Data pane. DAX table and column names are case-sensitive.

Make sure the column reference uses square brackets: network_kpi_data[Uptime_Pct]. Missing brackets cause a syntax error.

Help me fix my DAX measure in Power BI.

Before moving on, take a moment to review Page 2. Do you think the AI visuals gave you answers that your basic bar chart and line chart on Page 1 could not?

Your Key Influencers visual should show Weather: Storm and Maintenance_Status: Emergency as top factors. Your Decomposition Tree should let you drill from high packet loss down through Region, then Tower_ID, then Weather to find the specific towers and conditions causing problems. Your Card displays the below-target uptime percentage.

Your dashboard now has two pages: an overview page with trends and KPIs, and an analysis page with AI visuals for root cause investigation. Next up, you will add Smart Narratives and Anomaly Detection to make the dashboard self-explanatory for stakeholders.

Add Smart Narratives and Anomaly Detection

In the previous step, you added AI visuals that explain why network issues happen. But those visuals require interactive exploration.

Stakeholders do not always have time to click through charts. In this step, you will add two features that make your dashboard self-explanatory: Anomaly Detection flags unusual data points automatically, and Smart Narratives generate plain English summaries of what the data shows. Together, they turn your dashboard into a tool that communicates findings on its own.

In this step, get ready to:
  • Enable Anomaly Detection on your throughput line chart to automatically flag unusual dips.
  • Add a Smart Narrative visual that auto-generates a plain English summary of your data.
  • Polish your dashboard with a title, consistent theme, and clear visual titles.
Enable anomaly detection on your throughput chart

Your line chart shows throughput over time, but you have to visually scan every dip to spot problems. Anomaly Detection uses an algorithm to automatically flag data points that fall outside the expected range.

  • Switch back to your first report page (Page 1) by clicking the page tab at the bottom of the Power BI Desktop canvas.
  • Click on the line chart showing average Throughput_Mbps over time to select it.
  • In the Visualizations pane on the right, click the Analytics icon (the magnifying glass icon).
  • Expand the Anomalies section.
  • Toggle Anomalies to On.

Power BI adds anomaly markers and a shaded expected-range band to your line chart. You should see small dots marking data points that fall outside the expected boundary.

  • In the Anomalies section, find the Sensitivity slider and set it to around 75%.

What does Sensitivity control?

Higher sensitivity means the algorithm flags more anomalies, including smaller deviations. Lower sensitivity only flags the most significant spikes and dips. Setting it to around 75% gives a good balance for this dataset.

  • Click on one of the anomaly markers on the chart.

Power BI opens an explanations pane showing which fields contributed most to this unusual data point. Look for anomalies around mid-March 2026. This is where TOWER-S03's two-week outage drags down the average throughput, and the algorithm should flag it.

Don't see any anomaly markers?

Make sure you selected the line chart before opening the Analytics pane. The Anomalies section only appears for line chart visuals with time series data on the axis.

If you still do not see it, check that your X-axis field is the Date column set to Date type (not Text). A text-type date column does not support anomaly detection.

Why can't I see anomaly markers on my line chart?

Add a Smart Narrative visual

Your charts now flag unusual data points automatically. The next addition lets Power BI describe the data in words. The Smart Narrative visual auto-generates a plain English summary based on the visuals on the current page.

  • Click on an empty area of the Page 1 canvas to deselect any visual.
  • In the Visualizations pane, click the Smart narrative icon.

Where is the Smart narrative icon?

Look for a text-with-lines icon in the Visualizations pane. If you do not see it, click the More options (...) at the bottom of the pane and select Restore default visuals to bring back all built-in visual types.

Power BI creates a text box on your canvas with auto-generated text describing key trends and notable values from the visuals on this page.

What does the Smart Narrative show?

The narrative analyzes all visuals on the current page and highlights key findings. It mentions things like which region has the highest or lowest average throughput, and overall trends in the data.

This project uses Custom mode, which works in free Power BI Desktop. You can click into the text and add dynamic values from your data fields. Copilot mode is also available but requires a separate Copilot license.

  • Resize the Smart Narrative visual so it fits alongside your other visuals on Page 1 without overlapping.

Your dashboard now explains itself in words. A stakeholder can glance at the narrative and understand the key takeaways without interacting with any charts.

Narrative says it could not generate a summary?

Make sure you clicked on an empty area of the canvas first, not on an existing visual. If the Smart Narrative is added while a visual is selected, it may try to summarize only that visual and produce limited output.

Help me get the Smart Narrative to summarize my whole page.

Polish the dashboard

Your visuals and AI features are in place. A final polish pass makes the dashboard look professional and ready to share with stakeholders.

  • Click the Insert tab in the top ribbon.
  • Click Text box.
  • Type Network Performance Dashboard into the text box.
  • Drag the text box to the top of the Page 1 canvas so it serves as the dashboard title.
  • Increase the font size (e.g., 20 or larger) and bold the text so it stands out.

You should see your title text displayed prominently at the top of the page.

  • Click the View tab in the top ribbon.
  • In the Themes dropdown, select a built-in color theme that you like. This applies a consistent color palette across all visuals on every page.

All your charts, cards, and visuals now share a unified color scheme.

  • Click on each visual (line chart, bar chart, cards) and check that it has a clear, descriptive title. You can edit a visual's title by selecting the visual, clicking the Format visual icon (paint roller) in the Visualizations pane, expanding General, and editing the Title text.
  • Switch to Page 2 and repeat the same title check for your Key Influencers, Decomposition Tree, and Below Target Uptime card.

Before you call this step done, take a moment to predict what you expect to see.

  • Switch back to Page 1. Do you think the anomaly markers will highlight the mid-March throughput dip caused by TOWER-S03's outage?

Look at the line chart. You should see anomaly markers clustered around mid-March 2026, exactly when TOWER-S03 had its simulated outage. Your Smart Narrative visual displays auto-generated text summarizing key trends. Your title sits at the top, and all visuals share a consistent color theme.

What does your finished dashboard include?

Your dashboard now has two pages. Page 1 is the overview with throughput trends, KPI cards, a region slicer, anomaly detection, and a narrative summary. Page 2 is the AI analysis page with Key Influencers, Decomposition Tree, and the Below Target Uptime measure.

Together, these pages let a stakeholder see what is happening (Page 1) and understand why it is happening (Page 2), without writing a single line of analysis code.

Your dashboard is now polished and self-explanatory. Next up, take on the Secret Mission and embed a Python-powered forecast visual directly inside Power BI.

Secret mission

Add a Python Forecast Visual

Your dashboard shows what happened and why. But can you make it predict what happens next? Use Python inside Power BI to build a trend forecast for network throughput, combining scripting and machine learning in one visual.

Clean Up Your Resources

Clean Up Your Resources

This project runs entirely locally using free tools, so there are no ongoing costs or cloud resources to worry about. Decide whether to keep your files for future use, close things down temporarily, or delete everything entirely.

Resources you used:

  • telecom-dashboard project folder on your Desktop (containing generate_network_data.py and network_kpi_data.csv).
  • Power BI report file (.pbix).
  • pandas and matplotlib Python libraries installed via pip.
  • scikit-learn Python library (if you completed the Secret Mission).

Keep everything running

No action needed. Choose this if you want to keep building on your dashboard or revisit your data generation script later.

  • Your telecom-dashboard folder stays on your Desktop with generate_network_data.py and network_kpi_data.csv ready to use.
  • You can re-run generate_network_data.py at any time to generate fresh data with different parameters or patterns.
  • You can export your Power BI report as a PDF by clicking File, then Export to PDF to share it without needing a Power BI Pro license.

Pause - I'll come back to this later

Close Power BI Desktop to free up memory. Your files stay on disk until you are ready to return.

  • Save your Power BI report by pressing Ctrl+S before closing.
  • Close Power BI Desktop.
  • Your telecom-dashboard folder, Python script, CSV data, and .pbix file all remain on your machine. When you are ready to continue, open the .pbix file to pick up where you left off.

Delete - I don't want to use this again

Remove all project files and installed libraries to start fresh. This cannot be undone.

  • Save and close Power BI Desktop if it is still open.
  • Delete the telecom-dashboard project folder from your Desktop. On macOS or Linux, run:
rm -rf ~/Desktop/telecom-dashboard

On Windows, run:

rmdir /s /q "$env:USERPROFILE\Desktop\telecom-dashboard"
  • If you saved your .pbix file outside the telecom-dashboard folder, find and delete it from that location as well.
  • Uninstall the Python libraries you installed for this project by running:
pip uninstall pandas matplotlib -y
  • If you completed the Secret Mission, also uninstall scikit-learn by running:
pip uninstall scikit-learn -y

Nice Work!

Nice Work!

You just built a full end-to-end data pipeline, from a Python script generating realistic telecom data to a multi-page Power BI dashboard that uses AI to surface why network issues happen.

You've learned how to:

  • Automate data generation with a Python script that encodes realistic telecom network patterns and anomalies into a repeatable CSV output.
  • Use Power BI's AI visuals (Key Influencers and Decomposition Tree) to statistically identify root causes of network packet loss and drill down from region-level issues to specific towers.
  • Add Anomaly Detection and Smart Narratives to make a dashboard self-explanatory for stakeholders who do not have time to explore charts interactively.
  • Secret Mission: Embedded a Python-powered linear regression forecast visual inside Power BI, combining scripting and AI in one tool.

Ready to quiz yourself?