A Power BI report page takes 30 seconds to render — how do you find which visual is responsible?
answer
- do not guess, record the page refresh
- Desktop has a built-in recorder for this
- each entry splits into three timings
- every visual is at least one query of its own
- the generated query can be copied out and run
basics
~20 sRun Performance Analyzer in Power BI Desktop: it records each visual's time split into DAX query, visual display and other, so you can see which visual dominates and whether the cost is the model query or the rendering. Fix that one rather than guessing.
solid answer
~50 sMeasure before changing anything. **Performance Analyzer** in Power BI Desktop records a page refresh and lists every visual with its duration broken into **DAX query**, **visual display** and **other**, and lets you copy the generated DAX for a slow visual to run and dissect elsewhere. The split tells you where to aim: a long DAX query means the measure or the model is the problem; a long display time means the visual is drawing too many points or is a heavy custom visual; a large "other" often means the visual is waiting behind other queries. Remember that every visual on the page fires at least one query of its own, so twenty visuals means a burst of concurrent queries on every interaction. The fixes follow from the diagnosis: split the page, move detail behind drill-through, turn off interactions you do not need, reduce the points a chart plots, and simplify the measure or model behind the worst visual.
code
text · 12 linesPerformance Analyzer (page refresh, ms)
Visual DAX query Display Other Total
------------------------- --------- -------- ------ ------
Sales by Customer (table) 21 400 980 1 210 23 590
Revenue by Month (line) 310 140 90 540
Margin % (card) 180 60 70 310
Top Products (bar) 240 110 80 430
-- One visual owns almost all of the page, and its cost is the
-- model query, not rendering: copy that DAX out and dissect it,
-- and stop optimising the other three.go deeper
Know that Power BI Desktop has a Performance Analyzer that times each visual on a page refresh, and that you use it before changing anything.
Explain the DAX query / visual display / other split and what each points at, and that the generated DAX query can be copied out and run on its own.
Show the loop: measure, isolate the dominant visual, change one thing, re-measure — plus the layout-level fixes (fewer visuals, fewer interactions, detail behind drill-through) and knowing when the problem is the Service rather than the report.
Own the standard: a performance budget per page, a house rule about visual counts and raw-row tables, and the call on import versus DirectQuery and aggregations rather than escalating capacity spend.
## Measure first The wrong answer to this question is a list of best practices. The right answer starts with instrumentation, because report slowness is almost always concentrated: one visual, or one measure, accounts for most of the wall clock, and the other nineteen are noise. **Performance Analyzer** ships in Power BI Desktop. You start recording, refresh the visuals, and get a per-visual log. Each entry breaks into three parts: - **DAX query** — time the semantic model spent producing the result set. This is the model's problem: measure complexity, cardinality, DirectQuery round-trips, or filters that cannot travel efficiently. - **Visual display** — time the visual spent rendering what came back. High values mean too many data points, a table with thousands of rows, a map with heavy shapes, or a custom visual with slow rendering code. - **Other** — preparation, waiting for other queries, and background work. A large "other" across many visuals usually means queuing: the page is asking for too much at once. Performance Analyzer also exposes the **DAX query text** each visual generated, and you can copy it out and run it in an external tool to time it in isolation. That is the standard escalation path once you know which visual is guilty. ## Reading the result The split is the diagnosis. *One visual, huge DAX query time.* The measure behind it is doing too much work — iterating a large table row by row, or a filter that cannot be pushed down. Look at that measure and the model behind it, not the canvas. *Many visuals, moderate DAX time each.* Nothing is individually broken; there are simply too many queries. The fix is layout: fewer visuals on the page, detail moved behind a drill-through page, and interactions turned off between visuals that do not need to talk, so a single click does not re-fire everything. *Long visual display with short query time.* The visual is being asked to draw too much. A table with tens of thousands of rows, a scatter chart with a huge number of points, or a custom visual that renders slowly. Aggregate before plotting, or replace the visual. *Slow only in the Service, fast in Desktop.* Now it is not the report layout. Look at storage mode, the gateway if one is in the path, capacity load and concurrent users — a DirectQuery page pays a source round-trip per visual per interaction, so the source system's concurrency is in play. ## What actually moves the needle Roughly in order of payoff for a slow *page*, once you know which visual is at fault: 1. **Fewer visuals per page.** The blunt instrument, and it works. Every visual is at least one query. Summary pages should be small; detail belongs behind drill-through. 2. **Turn off interactions you do not need.** Each click re-queries every interacting target, so a page where nothing filters anything unnecessary fires a fraction of the queries. 3. **Reduce what each visual asks for.** Fewer points, fewer columns in a table, top-N filters instead of unbounded lists, and no visual that dumps raw rows onto a summary page. 4. **Fix the guilty measure or model.** Simplify the DAX, remove needless iteration, and check that the model shape lets filters travel efficiently. Model design is the neighbouring topic, but the report page is where its cost becomes visible. 5. **Prefer import over DirectQuery where the requirement allows**, or introduce aggregations, when DAX time is dominated by source round-trips. ## Things candidates say that do not help "Buy more capacity" before measuring. Capacity helps a throughput problem; it does not rescue one visual issuing an expensive query, and it is an expensive way to avoid a diagnosis. "Convert measures to calculated columns." Sometimes right, often wrong, and never a blind rule — a calculated column costs model size and refresh time and is fixed at one grain. Cosmetic changes such as hiding the filter pane: no query is saved. ## Reporting the finding The senior habit an interviewer is listening for is a loop, not a list: measure with Performance Analyzer, identify the dominant visual, isolate its query, change one thing, re-measure, and record what the change bought. And know when the answer is not a tweak at all — a page that is a data extract in disguise, with a forty-column table of raw rows, should be a paginated report or an export, not a dashboard visual asked to draw the warehouse.
- Performance Analyzer shows a visual with a short DAX query but a long visual display time. What do you change?The visual, not the model. Long display time means it is drawing too much — a table of thousands of rows, a scatter with a huge point count, or a slow custom visual. Aggregate before plotting, apply a top-N filter, cut columns, or swap the custom visual for a native one, then re-measure.
- The report is fast in Power BI Desktop but slow for users in the Service. Where do you look?Outside the report layout. Check storage mode — a DirectQuery model pays a source round-trip per visual, so source concurrency and queueing matter — plus gateway throughput if one is in the path, capacity load and concurrent users, and whether the Desktop test benefited from a warm cache and a single user.
- Why does reducing the number of visuals on a page help more than it looks like it should?Each visual issues at least one query, and every interaction re-fires the queries of all interacting targets. A page with twenty visuals turns one click into a burst of concurrent queries competing for the same model. Halving the visuals, or setting unnecessary interactions to None, cuts that burst proportionally.
saying these in an interview costs you the question
- Proposes buying more capacity before measuring anything
- Treats every slow page as a DAX problem without checking display time
- Says a calculated column is always faster than a measure
- Ignores that each visual issues its own query on every interaction
- Tests only in Desktop and never under Service conditions