Power BI Visualizations and Dashboards: Every Chart Type, Bar, Line, Pie, Scatter, Waterfall, Treemap, Funnel, Gauge, KPI Cards, Matrix, Maps, Slicers, Drill-Through, Bookmarks, and Choosing the Right Chart

Leave a Comment / Data Engineering, Power BI

Table of Contents

In the previous post, we covered Power BI architecture — semantic models, storage modes, refresh, and licensing. Now let us look at the output — the charts, dashboards, and interactive features that business users actually see. Data engineers do not typically build these visuals, but you need to understand them for three reasons: you design the star schema that powers them, you troubleshoot performance when they are slow, and you are asked about them in interviews.

Analogy — A restaurant menu. Each chart type is a dish on the menu. A bar chart is a steak — reliable, works for almost everything. A pie chart is sushi — elegant for the right occasion, terrible when overused. A KPI card is an appetizer — small, focused, whets the appetite. A matrix is the buffet — everything is there, but overwhelming without guidance. This post is the menu guide — which dish (chart) to serve for which occasion (data question).

Visualizations Through a Data Engineer’s Lens

Why data engineers should understand visualizations:

  1. SCHEMA DESIGN drives chart performance
     A bar chart showing revenue by region requires a clean dimension table
     with a region column. If your gold layer has "ON", "Ontario", and "Ont"
     for the same region, the chart shows three bars instead of one.

  2. AGGREGATION LEVEL matters
     A line chart showing daily trends needs date-grain data.
     If your gold table is at monthly grain, the line chart has 12 points
     instead of 365 -- misleading for trend analysis.

  3. PERFORMANCE troubleshooting
     A matrix visual with 100,000 rows in a DirectQuery model sends a massive
     SQL query to the source. Understanding which visuals are expensive helps
     you optimize the data model.

  4. INTERVIEW QUESTIONS
     "What chart would you use to show revenue by product category?"
     "When would you use a waterfall chart?"
     Every data engineering interview tests basic visualization knowledge.

Bar and Column Charts — Comparing Categories

Bar charts (horizontal) and column charts (vertical) are the most common visuals. They compare values across categories.

Types:
  Clustered Bar/Column:    Side-by-side bars per category (compare A vs B vs C)
  Stacked Bar/Column:      Bars stacked on top of each other (show total + composition)
  100% Stacked:            Bars show percentage composition (normalize to 100%)

When to use:
  - Comparing values across categories (revenue by region, orders by product)
  - Ranking items (top 10 customers, bottom 5 products)
  - Showing changes over discrete periods (quarterly revenue)

Bar (horizontal) vs Column (vertical):
  - Use horizontal bars when category names are long ("British Columbia" vs "BC")
  - Use vertical columns when the axis is time-based (months, quarters)
  - Use horizontal bars for ranking (longest bar = highest value, intuitive top-to-bottom)

Example use cases for data engineers:
  - Pipeline run counts by status (succeeded, failed, cancelled)
  - Data volume loaded per source system
  - Query execution time by warehouse (Snowflake)
  - Error counts by pipeline name

Line charts connect data points with a line to show trends. Area charts fill the space below the line to emphasize volume.

Types:
  Line Chart:         Single or multiple lines showing trends over time
  Area Chart:         Filled area under the line (emphasizes magnitude)
  Stacked Area:       Multiple areas stacked (show total + composition over time)

When to use:
  - Time series data (daily revenue, monthly active users, weekly pipeline runs)
  - Showing trends, seasonality, or growth patterns
  - Comparing multiple metrics over the same time period (revenue vs cost)

When NOT to use:
  - Fewer than 5 data points (use a bar chart instead)
  - Categories without a natural order (regions -- use bar chart)
  - Too many lines (more than 5 lines becomes unreadable)

Example use cases:
  - Daily data volume ingested over the past 90 days
  - Pipeline execution duration trend (is it getting slower?)
  - Monthly revenue by product line (multiple lines)
  - Snowflake credit consumption trend

Pie and Donut Charts — Parts of a Whole

Pie charts show how parts contribute to a total. Donut charts are pie charts with a hollow center.

When to use:
  - Showing proportions of a WHOLE (market share, budget allocation)
  - Maximum 5-6 slices (more than 6 becomes unreadable)
  - One clear dominant category (quick "who has the most?" answer)

When NOT to use:
  - Comparing similar-sized categories (humans are bad at comparing angles)
  - More than 6 categories (use a bar chart instead)
  - Showing trends over time (use a line chart)
  - Precise comparisons needed (bar charts are more accurate visually)

The rule:
  If you cannot tell which slice is bigger at a glance,
  use a bar chart instead. Pie charts are for "one slice dominates"
  situations, not "evenly distributed" situations.

Example use cases:
  - Revenue split by region (3-4 regions)
  - Data source contribution to total pipeline volume
  - Success vs failure ratio of pipeline runs

Scatter and Bubble Charts — Relationships Between Variables

Scatter charts plot two variables on X and Y axes to reveal correlations. Bubble charts add a third variable as the size of each point.

When to use:
  - Finding correlations (does spending more on marketing increase revenue?)
  - Identifying outliers (which product has unusually high cost but low revenue?)
  - Comparing entities on two dimensions (customers by order count vs average order value)
  - Adding a third variable via bubble size (revenue + order count + customer count)

When NOT to use:
  - Categorical comparisons (use bar chart)
  - Time trends (use line chart)
  - Small datasets with fewer than 10 points

Example use cases:
  - Clusters by revenue and order frequency (who are your best customers?)
  - Pipeline duration vs data volume (do bigger loads take proportionally longer?)
  - Warehouse query time vs data scanned (Snowflake optimization)

Waterfall Charts — Cumulative Impact

Waterfall charts show how a starting value is increased or decreased by a series of positive and negative changes, ending at a final value.

When to use:
  - Revenue bridge: Q1 revenue → +new customers → -churn → Q2 revenue
  - Budget variance: planned budget → +overruns → -savings → actual spend
  - Understanding sequential impacts on a total

Structure:
  Starting value (green/grey) → positive changes (green) → negative changes (red) → ending value

Example use cases:
  - Monthly revenue change breakdown (what grew, what shrank)
  - Pipeline cost analysis (base cost + compute + storage - optimizations = total)
  - Data quality: initial row count → rows removed by each validation rule → final count

Treemap Charts — Hierarchical Proportions

Treemaps display hierarchical data as nested rectangles, where size represents value. Larger rectangles = larger values.

When to use:
  - Showing proportions across MANY categories (too many for a pie chart)
  - Hierarchical data (category → subcategory → product)
  - Space-efficient display of large categorical datasets
  - Quick visual scan of "what is biggest?"

When NOT to use:
  - Precise comparisons needed (rectangle sizes are hard to compare exactly)
  - Non-hierarchical data with few categories (use bar chart)
  - Time-based data (use line chart)

Example use cases:
  - Data volume by source system → by table (nested hierarchy)
  - Storage usage across databases → schemas → tables
  - Revenue by region → city → product category

Funnel Charts — Sequential Stages

Funnel charts show values decreasing through sequential stages, like a sales pipeline or conversion process.

When to use:
  - Sales pipeline: Lead → Qualified → Proposal → Negotiation → Closed
  - Conversion rates: Website Visit → Sign Up → Trial → Paid → Renewal
  - Data pipeline stages: Raw → Validated → Cleaned → Enriched → Loaded

Each stage shows:
  - The count or value at that stage
  - The drop-off from the previous stage (visually narrows)

Example use cases:
  - Data quality pipeline: rows ingested → passed validation → passed dedup → loaded to gold
  - User onboarding funnel: registered → activated → first action → retained

Gauge Charts — Progress Toward a Goal

Gauge charts display a single value against a target, using a needle on a dial (like a speedometer).

When to use:
  - Tracking progress toward a specific goal (85% of SLA target met)
  - Single KPI with a defined minimum, maximum, and target
  - Executive summaries (one number, one goal, one visual)

When NOT to use:
  - Multiple metrics (use KPI cards or bar charts)
  - Precise values needed (gauges are approximate)
  - No defined target (gauges need a goal to be meaningful)

Example use cases:
  - Pipeline SLA: 95% uptime target, currently at 92%
  - Data freshness: target refresh within 1 hour, current lag 45 minutes
  - Budget utilization: 78% of monthly compute budget consumed

KPI Cards — Single Metric Spotlight

KPI (Key Performance Indicator) visuals display a single metric with a trend indicator and target comparison. Card visuals show just the number.

Card visual:
  - Displays a single number prominently (e.g., $1.2M Total Revenue)
  - No trend, no target -- just the value
  - Use for: headline numbers at the top of a dashboard

Multi-row Card:
  - Multiple metrics in one visual (Revenue, Orders, Avg Order Value)
  - Compact way to show several KPIs

KPI visual:
  - Single metric + trend line + target comparison
  - Shows: current value, target, percentage of target, trend over time
  - Color-coded: green (on target), red (behind target)
  - Use for: performance tracking against goals

Example layout (top of any dashboard):
  [Total Revenue]  [Total Orders]  [Avg Order Value]  [Pipeline Success %]
      $1.2M            45,230           $26.54              97.3%
  Cards or KPIs across the top give the instant executive summary.

Tables and Matrix — Detailed Data

Tables show flat data in rows and columns. Matrix visuals show data in a pivot-table format with row and column hierarchies.

Table visual:
  - Flat rows and columns (like a spreadsheet)
  - Good for: detailed transaction data, audit logs, drill-through pages
  - Supports conditional formatting (color bars, icons, background colors)
  - Avoid: more than 20 columns or thousands of rows (too much data)

Matrix visual:
  - Pivot table format (rows + columns + values)
  - Supports hierarchical drill-down (Year → Quarter → Month)
  - Row subtotals and grand totals
  - Good for: cross-tabulated summaries (revenue by region AND product)
  - Power BI equivalent of Excel pivot tables

Example use cases:
  Table: Pipeline run log (pipeline name, start time, duration, status, rows loaded)
  Matrix: Revenue by region (rows) and quarter (columns) with yearly totals

Map Visuals — Geographic Data

Map types in Power BI:

  Bing Maps (bubble):
    - Plots bubbles on a map based on latitude/longitude or location names
    - Bubble size represents a measure (revenue, population)

  Filled Map (choropleth):
    - Colors regions/countries by a measure
    - Darker color = higher value
    - Good for: geographic heatmaps (revenue by country, orders by state)

  Azure Maps:
    - More advanced mapping with layers, reference data, and custom styling
    - Requires Azure Maps account

  Shape Map:
    - Custom geographic shapes (custom regions, floor plans, store layouts)

When to use maps:
  - Data has a geographic dimension (country, state, city, zip code)
  - Spatial patterns matter (where are our highest-value customers?)

When NOT to use:
  - Comparing exact values (bar chart is more precise)
  - Non-geographic categories
  - Indoor/non-geographic spatial data (unless using Shape Map)

Choosing the Right Chart — The Decision Guide

What question are you answering?

  "How much of each?" (comparison)
    → Bar/Column Chart
    Categories: regions, products, departments
    Example: Revenue by region

  "How does it change over time?" (trend)
    → Line Chart (or Area Chart for volume emphasis)
    Time axis: daily, weekly, monthly, quarterly
    Example: Monthly revenue trend

  "What proportion is each part?" (composition)
    → Pie/Donut (5 or fewer categories)
    → Treemap (6+ categories or hierarchical)
    → Stacked Bar (composition over time)
    Example: Market share by competitor

  "Is there a relationship?" (correlation)
    → Scatter/Bubble Chart
    Two numeric variables on X and Y
    Example: Marketing spend vs revenue

  "How do parts add up to a total?" (cumulative)
    → Waterfall Chart
    Sequential positive and negative impacts
    Example: Revenue bridge from Q1 to Q2

  "How does a value flow through stages?" (sequential)
    → Funnel Chart
    Decreasing values through pipeline stages
    Example: Sales conversion funnel

  "Are we on target?" (performance)
    → KPI Card or Gauge Chart
    Single metric vs goal
    Example: Pipeline SLA tracking

  "What are the details?" (exploration)
    → Table (flat data) or Matrix (pivoted)
    Detailed rows for drill-through pages
    Example: Pipeline run history log

Slicers — Interactive Filters

Slicers are on-canvas filter controls that let users interactively filter all visuals on the page.

Slicer types:

  List slicer:       Checkboxes or radio buttons (region, product category)
  Dropdown slicer:   Dropdown menu (saves space, many options)
  Date range slicer: Date picker with from/to (filter by date range)
  Between slicer:    Numeric range slider (filter amount between $100-$500)
  Relative date:     "Last 30 days", "This month", "Last quarter"

Best practices:
  - Place slicers at the top or left side of the report (consistent location)
  - Use "Select All" option for multi-select slicers
  - Sync slicers across pages (Slicer → Sync Slicers pane)
  - Limit slicers to 3-5 per page (too many creates confusion)
  - Use the relative date slicer for dashboards that auto-filter to recent data

Data engineering impact:
  Every slicer interaction triggers a query to the semantic model.
  DirectQuery: each slicer click = new SQL query to source.
  Import: each click queries the in-memory model (fast).
  Direct Lake: each click reads from OneLake cache (fast after first load).

Drill-Through — Deep Dive on Demand

Drill-through lets users right-click on a data point in one page and navigate to a detail page filtered to that specific item.

How it works:

  Page 1: Summary dashboard showing revenue by region
    User right-clicks "Ontario" → Drill Through → "Region Details" page

  Page 2 (Region Details): Pre-filtered to Ontario
    Shows: Ontario orders, Ontario customers, Ontario pipeline history
    "Back" button returns to the summary page

  Setup:
    1. Create a detail page (e.g., "Region Details")
    2. Add a drill-through filter field (e.g., Region)
    3. Power BI automatically adds a "Back" button
    4. On the summary page, users right-click any Region value → Drill through

  Use cases:
    - Summary → detailed transaction view
    - Pipeline overview → individual pipeline run details
    - Customer segment → individual customer profile

Bookmarks — Saved Views and Navigation

Bookmarks capture the current state of a report page — which filters are applied, which visuals are visible, and where the user has scrolled.

Bookmark use cases:

  Navigation buttons:
    Create bookmarks for different views of the same data
    Add buttons that switch between bookmarks
    Example: "Revenue View" button and "Cost View" button on the same page

  Toggle visibility:
    Show/hide visuals using bookmarks
    Example: "Show Details" button shows a table, "Hide Details" hides it

  Storytelling:
    Create a sequence of bookmarks that tell a data story
    Example: Slide 1 (overview) → Slide 2 (problem) → Slide 3 (root cause)

  Default filters:
    Save a bookmark with specific slicer selections as the landing state
    Users land on a pre-filtered view (e.g., current month, their region)

Conditional Formatting — Data-Driven Styling

Conditional formatting options:

  Background color:   Color cells based on value (red for low, green for high)
  Font color:         Change text color based on value
  Data bars:          Mini bar charts inside table/matrix cells
  Icons:              Arrows, flags, or traffic lights based on rules
  Web URL:            Make values clickable links

  Applied to:
    Table and Matrix cells
    Card visuals (font color)
    Bar chart data labels

  Rules-based vs gradient:
    Rules: value > 1000 → green, value < 500 → red
    Gradient: smooth color scale from min (light) to max (dark)

Example:
  Pipeline status table:
    Status = "Success" → green background
    Status = "Failed"  → red background
    Duration > SLA     → red font + warning icon

Tooltips — Context on Hover

Default tooltips:
  Hover over any data point → see the underlying values
  Power BI generates these automatically

Custom tooltips:
  Create a separate report page sized as a tooltip (type: Tooltip)
  Add visuals to the tooltip page (charts, cards, images)
  Assign the tooltip page to a visual
  Hover → see a rich, multi-visual tooltip instead of plain text

Example:
  Hover over a region bar → tooltip shows:
    - Revenue trend (small line chart)
    - Top 5 customers (small table)
    - YoY growth percentage (card)
  All in a compact tooltip popup

Reports vs Dashboards — What’s the Difference

Report:
  - Multi-page interactive document
  - Built in Power BI Desktop or Service
  - Contains visuals, slicers, drill-through, bookmarks
  - Connected to ONE semantic model
  - Saved as .pbix or in a workspace
  - Can be shared via workspace, app, or link

Dashboard:
  - Single-page collection of PINNED tiles from multiple reports
  - Built only in Power BI Service (not Desktop)
  - Tiles can come from different reports and different semantic models
  - No slicers (view-only tiles)
  - Click a tile → navigates to the source report
  - Used for: executive overview combining multiple reports

  Report = the full interactive analysis
  Dashboard = the curated summary view (tiles from multiple reports)

  For data engineers:
    You build the semantic model → analysts create reports → managers pin tiles to dashboards

Common Mistakes

  1. Using pie charts for more than 5 categories. A pie chart with 12 slices is unreadable. If humans cannot tell which slice is bigger at a glance, the chart has failed. Use a horizontal bar chart for 6+ categories — it is always more accurate and readable.

  2. Putting too many visuals on one page. A report page with 15 visuals is overwhelming. Each visual competes for attention, and every visual sends a query to the model (slowing the page). Aim for 5-8 visuals per page maximum. Use drill-through for details instead of cramming everything on one page.

  3. Using 3D effects on charts. 3D adds visual complexity without adding information. A 3D bar chart is harder to read than a 2D one. A 3D pie chart distorts proportions (back slices appear larger). Always use flat, 2D visuals.

  4. Not using slicers consistently. If Page 1 has a date slicer at the top left and Page 2 has it at the bottom right, users get confused. Keep slicers in the same position on every page. Sync slicers across pages so filtering carries over.

  5. Choosing the wrong chart for the data. A line chart for categorical data (regions) creates misleading “trends” between unrelated categories. A bar chart for 500 data points creates an unreadable wall of bars. Match the chart to the data type: categories → bar, time → line, proportions → pie/treemap.

  6. Overusing conditional formatting. When every cell in a matrix has background colors, icons, and data bars, the formatting becomes noise. Use conditional formatting sparingly to highlight exceptions (red for failed, green for on-target), not to color every cell.

  7. Not providing context with KPI cards. A card showing “$1.2M Revenue” is meaningless without context. Is that good or bad? Add a comparison: previous period ($1.1M, +9%), target ($1.3M, 92% achieved), or trend (arrow up/down). Use the KPI visual instead of a plain card when targets exist.

  8. Building reports without a clear audience. An executive wants 3-4 KPI cards and a summary chart (30-second scan). An analyst wants interactive slicers, drill-through, and detailed matrices (10-minute exploration). Building one report for both audiences satisfies neither. Create separate pages or separate reports for each audience.

Interview Questions

Q: What chart would you use to compare revenue across five product categories? A: A clustered bar chart (horizontal) or column chart (vertical). Bar charts are the best choice for comparing values across categories because the human eye compares bar lengths more accurately than pie slice angles or scatter plot positions. Use horizontal bars if category names are long, vertical columns if the axis represents time periods.

Q: When would you use a waterfall chart? A: A waterfall chart shows how a starting value changes through sequential positive and negative contributions to reach a final value. Use it for revenue bridges (Q1 revenue + new customers – churn = Q2 revenue), budget variance analysis (planned – overruns + savings = actual), or any scenario where you need to explain what drove the change between two values.

Q: What is the difference between a slicer and a filter in Power BI? A: A slicer is a visual on the report canvas that users interact with directly (clicking, selecting, sliding). It is visible and intuitive. A filter is configured in the Filters pane and can be applied at the visual, page, or report level. Filters can be hidden from viewers. Use slicers for commonly used interactive filters (date range, region, product). Use filters for fixed constraints that users should not change (exclude test data, limit to active records).

Q: What is drill-through and when would you use it? A: Drill-through is a navigation feature where users right-click a data point on a summary page and navigate to a detail page pre-filtered to that item. Use it for summary-to-detail navigation: a revenue-by-region summary page drills through to a regional detail page showing orders, customers, and trends for that specific region. It reduces clutter on summary pages by moving details to dedicated drill-through pages.

Q: What is the difference between a Power BI report and a dashboard? A: A report is a multi-page interactive document connected to one semantic model, built in Desktop or Service, with slicers, drill-through, and bookmarks. A dashboard is a single-page collection of pinned tiles from potentially multiple reports and semantic models, built only in Service, with no slicers (view-only). Reports are for analysis. Dashboards are for executive overview — they show curated highlights from multiple reports.

Q: How do slicers affect performance in different storage modes? A: Every slicer interaction regenerates queries for all visuals on the page. In Import mode, queries run against the in-memory VertiPaq engine (fast, sub-second). In DirectQuery mode, every slicer click sends a new SQL query to the source database, which can be slow with complex queries or high concurrency. In Direct Lake mode, the first slicer interaction may load Delta files into memory, but subsequent interactions are fast (cached). For DirectQuery models, limit the number of slicers and visuals per page to reduce query load.

Q: How would you design a dashboard for an executive audience? A: Keep it to one page with 3-5 KPI cards across the top (revenue, orders, growth rate, SLA). Add 2-3 summary charts: a bar chart for top categories, a line chart for monthly trend, and one comparison (actual vs target). Use a single date slicer for time period selection. No detailed tables (use drill-through to a detail page). Include the company logo and last refresh timestamp. Green/red conditional formatting on KPIs for instant good/bad signals. The executive should get the full picture in 30 seconds.

Wrapping Up

Every chart in Power BI serves a specific purpose: bar charts compare categories, line charts show trends, pie charts show proportions (sparingly), waterfall charts explain changes, and KPI cards spotlight key metrics. The skill is not knowing how to create them — it is knowing which one to choose for which question. Data engineers need this knowledge to design star schemas that power these visuals, troubleshoot performance when reports are slow, and answer interview questions about visualization best practices.

In the next post, we will cover DAX — the formula language that powers Power BI measures and calculations. We will focus on what data engineers need to know: CALCULATE, filter context, time intelligence, and the formulas you will see in interviews.

Related posts: – Power BI Architecture – Power BI Direct Lake in Fabric – Star Schema and Normalization – SQL Window Functions – Fabric Lakehouse Deep Dive

Related Posts

Leave a Comment

Your email address will not be published. Required fields are marked *

Scroll to Top