fabric-pbi-perf-remediate
npx machina-cli add skill PatrickGallucci/fabric-skills/fabric-pbi-perf-remediate --openclawPower BI Performance remediate in Microsoft Fabric
Systematic toolkit for diagnosing, analyzing, and resolving Power BI performance bottlenecks across the Microsoft Fabric platform. Covers semantic model optimization, DAX tuning, capacity management, DirectQuery diagnostics, and report design best practices.
When to Use This Skill
- Power BI reports are slow to load or interact with
- DAX queries take too long to execute
- Semantic model refresh is slow or timing out
- Fabric capacity is throttled or overutilized
- DirectQuery reports have high latency
- Visuals render slowly or time out
- Users report intermittent performance degradation
- Migrating to Fabric and need to optimize for the new platform
- Planning capacity sizing for Power BI workloads
- Conducting a performance audit or health check
Prerequisites
| Tool | Purpose | Required |
|---|---|---|
| Power BI Desktop | Performance Analyzer, DAX query view | Yes |
| DAX Studio | Advanced DAX profiling and server timers | Recommended |
| Fabric Capacity Metrics App | Capacity utilization monitoring | Yes (admins) |
| Tabular Editor / Best Practice Analyzer | Semantic model analysis | Recommended |
| SQL Server Profiler | DirectQuery trace analysis | Optional |
| PowerShell 7+ | Automation scripts included in this skill | Optional |
Step-by-Step Workflows
Workflow 1: Initial Performance Triage
Determine where the bottleneck lives before diving deep.
- Reproduce the issue in Power BI Desktop with Performance Analyzer enabled
- View ribbon > Performance Analyzer > Start recording > Refresh visuals
- Categorize each visual by its dominant cost:
- DAX query duration > 500ms → Investigate semantic model / DAX
- Visual display duration > 500ms → Investigate report design
- Other duration > 500ms → Investigate data source / gateway
- Check capacity health using the Fabric Capacity Metrics app
- Look for overload (>100% utilization), throttling events, or queued operations
- Route to the appropriate deep-dive workflow below
Workflow 2: DAX Query Optimization
See dax-optimization-patterns.md for a comprehensive catalog of anti-patterns and fixes.
- Capture slow DAX from Performance Analyzer (copy query from visual)
- Open DAX query view in Power BI Desktop (or DAX Studio)
- Run query with Server Timings enabled (DAX Studio: Server Timings tab)
- Analyze the breakdown:
- Formula Engine (FE) time: DAX calculation overhead
- Storage Engine (SE) time: Data scan / retrieval overhead
- SE queries count: High count indicates poor query plan
- Apply optimization patterns from the reference guide
- Re-test and compare timings
Workflow 3: Semantic Model Optimization
See capacity-optimization.md for Fabric-specific tuning.
-
Run Best Practice Analyzer (Tabular Editor or Fabric notebook)
-
Address findings by priority:
- Remove unused columns and tables
- Fix incorrect data types (text dates, high-precision decimals)
- Replace calculated columns with calculated measures where possible
- Reduce cardinality on high-cardinality columns
-
Evaluate storage mode (Import vs DirectQuery vs Composite)
-
Configure incremental refresh for large fact tables
-
Enable VOrder for read-heavy Power BI workloads in Fabric:
spark.sql.parquet.vorder.default=trueOr use the
readHeavyForPBIresource profile at the environment level.
Workflow 4: Report Design Optimization
- Audit visual count per page (target: 8 or fewer interactive visuals)
- Identify high-cardinality visuals (tables/matrices with thousands of rows)
- Check for excessive cross-filtering between visuals
- Evaluate filter context complexity (many slicers, complex RLS)
- Consider:
- Bookmarks + drill-through instead of dense pages
- Pre-aggregated measures instead of visual-level calculations
- Paginated reports for large tabular exports
Workflow 5: DirectQuery Performance
See directquery-tuning.md for detailed guidance.
- Enable Performance Analyzer and identify slow DirectQuery visuals
- Locate trace files for SQL analysis:
- File > Options > Diagnostics > Open traces folder
- Find
FlightRecorderCurrent.trcin the active workspace
- Open trace in SQL Server Profiler and filter by
DirectQuery Begin/End - Analyze generated SQL for inefficient patterns
- Optimize at the source (indexes, views, materialized tables)
- Consider Composite model (Import aggregations + DirectQuery detail)
Workflow 6: Capacity Monitoring and Sizing
See capacity-optimization.md for detailed guidance.
- Install and configure the Fabric Capacity Metrics app
- Monitor key metrics:
- Interactive vs background operation split
- Throttling events and queue depth
- Per-item compute consumption
- Identify top consumers and optimize or reschedule them
- Right-size capacity SKU based on measured utilization
- Consider Autoscale Billing for Spark if bursty workloads exist
Quick Reference: Common Fixes
| Symptom | Likely Cause | Quick Fix |
|---|---|---|
| All visuals slow | Capacity overloaded | Scale up SKU or reduce concurrency |
| Single visual slow | Inefficient DAX measure | Profile in DAX Studio, rewrite measure |
| Slow after slicer change | High cardinality filter | Reduce distinct values or use Top N |
| Slow first load, fast after | Cold cache | Enable query caching; check refresh schedule |
| Slow in Service, fast in Desktop | Gateway bottleneck or capacity | Check gateway logs and capacity metrics |
| Refresh takes hours | No incremental refresh | Enable incremental refresh on fact tables |
| DirectQuery timeouts | Source query too slow | Add indexes; consider Import aggregations |
| Intermittent slowness | Capacity throttling | Review Capacity Metrics app for spikes |
Automation Scripts
Run the diagnostic PowerShell script to collect environment and configuration data:
# Collect Power BI workspace and dataset metadata for analysis
./scripts/Invoke-PBIPerformanceAnalysis.ps1 -WorkspaceId "<workspace-guid>"
Analyze DAX query patterns from a semantic model:
# Extract and evaluate DAX measures for common anti-patterns
./scripts/Get-DAXQueryMetrics.ps1 -DatasetId "<dataset-guid>" -WorkspaceId "<workspace-guid>"
Performance Assessment Template
Use the performance-report-template.md to document findings and recommendations from a performance audit.
remediate
| Issue | Resolution |
|---|---|
| Performance Analyzer shows no data | Ensure you clicked "Start recording" before refreshing |
| DAX Studio cannot connect | Check XMLA endpoint is enabled on capacity (requires P1/F64+) |
| Capacity Metrics app not available | App requires admin role; install from AppSource |
| VOrder not improving PBI performance | Verify readHeavyForPBI profile is active; check file format is Delta/Parquet |
| Best Practice Analyzer missing rules | Update to latest Tabular Editor; import community rules from te2.wiki |
| Scripts fail to authenticate | Run Connect-PowerBIServiceAccount first; ensure Power BI Management module installed |
References
- remediate Flowchart - Decision tree for systematic diagnosis
- DAX Optimization Patterns - Anti-patterns and proven fixes
- Capacity Optimization - Fabric capacity tuning for Power BI
- DirectQuery Tuning - Source optimization and Composite models
- Performance Report Template - Audit documentation template
- Microsoft: Optimization guide for Power BI
- Microsoft: Troubleshoot report performance
- Microsoft: Monitor report performance
- Microsoft: Evaluate and optimize Fabric capacity
Source
git clone https://github.com/PatrickGallucci/fabric-skills/blob/main/skills/fabric-pbi-perf-remediate/SKILL.mdView on GitHub Overview
Power BI Performance remediate in Microsoft Fabric provides a systematic toolkit to diagnose, analyze, and resolve performance bottlenecks across Fabric. It covers semantic model optimization, DAX tuning, capacity management, DirectQuery diagnostics, and best-practice report design to deliver faster insights. The approach leverages Performance Analyzer, DAX Studio, Fabric Capacity Metrics app, and Best Practice Analyzer to optimize workloads and workloads on Fabric, including patterns for incremental refresh, storage modes, and Spark resource profiles.
How This Skill Works
The skill guides you through triage and targeted deep-dives: capture performance data with Performance Analyzer, analyze DAX via DAX Studio, and assess capacity health with the Fabric Capacity Metrics app. It then applies documented optimization patterns for DAX, semantic models, and capacity, validating improvements with re-testing and workload profiling.
When to Use It
- Power BI reports load slowly or interact sluggishly in Fabric.
- DAX queries run slowly or show high FE (Formula Engine)/SE (Storage Engine) time.
- Semantic model refresh is slow or times out.
- Fabric capacity is throttled or overutilized.
- DirectQuery reports have high latency or visuals time out.
Quick Start
- Step 1: Reproduce the issue in Power BI Desktop with Performance Analyzer, then refresh visuals to capture timings.
- Step 2: Categorize visuals by dominant cost (DAX FE/SE time, render time, or data-source delays) and identify where to focus.
- Step 3: Check Fabric Capacity Metrics app for overload or throttling and route to the appropriate workflow (DAX, semantic model, or capacity).
Best Practices
- Always reproduce the issue in Power BI Desktop with Performance Analyzer before digging deeper.
- Capture slow DAX queries and analyze FE vs SE timings using DAX Studio (Server Timings).
- Run Fabric Capacity Metrics app to monitor capacity health, overload, and throttling events.
- Run Best Practice Analyzer (Tabular Editor or Fabric notebook) and fix findings by priority.
- Consult dax-optimization-patterns.md and capacity-optimization.md for proven remediation patterns; configure incremental refresh and appropriate storage modes.
Example Use Cases
- A slow order dashboard where FE time dominates; apply DAX tuning and semantic-model optimizations.
- A model with many unused columns causing long refresh times; prune the model via Best Practice Analyzer findings.
- DirectQuery latency due to non-foldable queries; rework visuals and queries to improve folding.
- Fabric capacity shows overload and queued operations; adjust capacity allocation or workload distribution.
- Incremental refresh misconfiguration causing full-refresh bottlenecks; implement proper incremental refresh settings.