skip to content

Power BI

4 roadmaps36 questionsupdated

Microsoft's stack from ingestion to sharing: Power Query for shaping, a star-schema model, DAX measures, report visuals, and the Service for distribution. Interviewers ask about it as a whole, because each layer's mistakes surface in the next one.

on this pageshow

guide

overview

~1 min

Power BI is a business-intelligence product, and interviews treat it as a pipeline rather than a charting tool: data is shaped in Power Query, loaded into a tabular model, calculated with DAX, drawn on report pages and distributed through the Power BI Service. Interviewers probe the seams between those layers, because a mistake made early rarely fails loudly. It surfaces two layers later as a slow refresh, a total nobody can explain, or a manager who can see another region's figures. The hub follows that pipeline. [Power Query (M)](/topics/data-power-bi-power-query) is shaping data before it reaches the model, and deciding whether that work runs at the source or on the refresh machine. [Data modeling](/topics/data-power-bi-data-modeling) is the star schema and its relationships, where most wrong numbers begin. [DAX measures](/topics/data-power-bi-dax-measures) is the calculation language and its two kinds of context. [Report visuals](/topics/data-power-bi-report-visuals) is the canvas and how visuals filter each other. [Power BI Service](/topics/data-power-bi-service-sharing) covers publishing, refresh, workspaces and apps, and [row-level security](/topics/data-power-bi-row-level-security) decides who sees which rows. Junior rounds check vocabulary: measure or column, merge or append, what a click on one chart does to the page. Senior and principal rounds turn into diagnosis and design: why a total looks wrong, why a refresh succeeded while the numbers stayed old, where a rule should live when several tools read the same data. Start where the data does, in Power Query, then spend the most time on the model and filter context: they explain most of what DAX, visuals and security do.

primer

### Five layers, one direction Power Query produces tables, the model relates them, DAX computes over those relationships, visuals ask the model questions, and the Service schedules, secures and shares the result. A strong answer names the layer a problem belongs to before proposing a fix, because the same symptom, a slow page or a wrong figure, can start in any of them. ### The model is a star Fact tables of events and transactions sit in the middle; dimensions such as date, product, customer and region surround them, joined on keys. Filters flow from a dimension down to its facts along one-to-many relationships. Departures from that shape (filters running both ways, many-to-many joins, snowflaked dimensions) are allowed, but each has a price interviewers expect you to name. ### Measures over columns A calculated column is computed at refresh and stored per row; a measure is a formula evaluated for every cell a visual shows. Most business logic belongs in measures, so one definition answers every slice of the data. Choosing between the two is the first DAX judgement an interviewer checks. ### Filter context decides every number Every aggregated figure on a report is evaluated under a set of filters assembled from the visual's grouping, slicers, cross-filtering, page and report filters, and security roles. `CALCULATE` exists to change that set. Once you can say which filters apply to one cell, totals, time intelligence and RLS stop looking like special cases. ### Where work runs decides speed Refresh time depends on how much Power Query pushes down to the source; query time on model size, relationship design and measure complexity; render time on how many visuals a page asks for. **Import** caches data in the in-memory engine, **DirectQuery** sends each visual's query to the source: the choice moves the cost rather than removing it. ### Security rides on the model Row-level security is a filter on the model, so beyond the table it is defined on it reaches only what relationships connect. Workspace roles, apps and permissions decide who reaches the model at all. Both are configured in the Service, but a sound security answer starts with the model's design.

Query folding
Power Query converting its steps into one native source query, so filters and aggregation run in the database before rows are transferred.
Semantic model
The published model behind reports: tables, relationships, measures, security roles and, in Import mode, the data itself. Formerly called a dataset.
Star schema
A model layout with fact tables of events at the centre and dimension tables of descriptive attributes around them, joined one-to-many on keys.
Cross-filter direction
The relationship setting that decides which way filters travel: from the one side to the many side by default, or both ways.
Measure
A named DAX formula evaluated at query time for each cell of a visual. It stores no values in the model.
Filter context
The set of filters in force when a DAX expression is evaluated, assembled from visuals, slicers, report filters, security roles and CALCULATE.
Row context
The notion of a current row, present in calculated columns and iterator functions. It identifies a row but does not filter the model.
CALCULATE
The DAX function that evaluates an expression under a modified filter context; the main tool for changing what a measure sees.
Iterator
A DAX function such as SUMX that evaluates an expression once per row of a table, then aggregates the results.
Date table
A table with one row per day over a continuous range, related to the facts and marked as the model's date table for time intelligence.
Storage mode
How a table's data is served: Import caches it in memory at refresh, DirectQuery queries the source each time a visual asks.
On-premises data gateway
Software installed inside a private network that lets the Power BI Service reach sources it cannot connect to directly.
Row-level security (RLS)
Roles on the semantic model holding DAX filters that limit the rows read-only users see, either fixed per role or driven by the signed-in user.
USERPRINCIPALNAME
A DAX function returning the signed-in user's sign-in name, used by dynamic RLS to look that user up in a mapping table.

Follow one refresh and one click. On refresh, the Service runs each query's applied steps, reaching through a gateway when the source sits in a private network. The folded part executes at the source, the rest on the machine doing the refresh, and the results load into the semantic model's tables. Calculated columns and calculated tables are recomputed and stored at the same moment; measures are not. When a reader opens a page, each visual sends a DAX query to the model. The visual's grouping, slicers, page and report filters, any cross-filter from a clicked visual, and the reader's RLS role together form the filter context. Relationships carry those filters from dimensions to facts, and measures are evaluated once per cell and again for each total. Nothing on the page stores numbers: bookmarks, drill-through and tooltips change what the next query asks, not what the model holds. The layers therefore depend on each other in one direction: - Power Query decides the **grain and keys** the model receives; a messy key reappears later as a (Blank) row or a relationship that cannot be built. - The model decides **which way filters can travel**, which bounds both DAX and RLS. - DAX decides **what each cell means**, so a non-additive measure produces a total that is correct and still surprising. - The Service decides **who reaches the model and how fresh it is**. One measure and one role show the layers meeting: ```dax // Measure on Sales: a ratio, so its total is a fresh evaluation, not a sum Margin % = VAR Revenue = SUM ( Sales[Revenue] ) VAR Cost = SUM ( Sales[Cost] ) RETURN DIVIDE ( Revenue - Cost, Revenue ) // Role "EMEA": a filter on the Region table, not on Sales [Region] = "EMEA" ``` The role never names Sales. It restricts Sales only because a relationship runs from Region to Sales, and it binds only readers without edit rights on the model. Replace the fixed value with a lookup of the signed-in user and the same design becomes dynamic RLS.

  1. Power Query (M) →

    Where the data enters: applied steps, merges and folding decide the tables, keys and refresh cost everything downstream inherits.

  2. Data Modeling →

    The star schema, relationships and filter direction that DAX, visuals and security all rely on; most wrong numbers start here.

  3. DAX Measures →

    Row and filter context, CALCULATE and iterators: the language makes sense only once the model it filters is clear.

  4. Report Visuals →

    How visuals filter each other and how drill-through, bookmarks and diagnosis of a slow page build on the model and measures.

  5. Power BI Service →

    Publishing, refresh through a gateway, workspaces and apps: how a finished model and report reach their readers.

  6. Row-Level Security →

    Last, because it combines a DAX filter, the model's relationships and the Service's workspace roles.

  • Writing business logic as calculated columns because they feel like spreadsheet formulas: the value is fixed at refresh, enlarges the model and ignores the reader's slicers.

  • Setting relationships to filter in both directions to make numbers appear, which creates ambiguous paths, slows queries and can widen what a security role lets through.

  • Expecting a matrix total to equal the sum of its rows; for ratios and distinct counts it is its own evaluation, see the total row question.

  • Running time-intelligence functions against the fact table's own date column instead of a continuous date table that is related to the facts and marked.

  • Placing a step that cannot fold early in a query, so every later filter runs on the refresh machine over the full source table.

  • Testing RLS while signed in as a workspace member and drawing a conclusion: editors are not filtered, so use View as or a Viewer account.

  • Treating a successful refresh as proof of fresh data without checking which model refreshed and whether the upstream load had finished.

Power BI is weighed most often against Tableau, Qlik Sense and Looker. A defensible comparison names each tool's centre of gravity: Power BI and Looker put a governed semantic model at the core, defined in DAX in one and LookML in the other, while Tableau's strength is visual exploration over the sources it connects to. In organisations already on Microsoft 365 and Azure, licensing and identity integration often settle the choice before features are compared. Its pieces are shared across Microsoft's analytics stack. The same tabular engine and DAX run in Analysis Services Tabular and in Excel's Power Pivot, and Power Query also appears in Excel and in dataflows, so the skills transfer. Microsoft Fabric now hosts Power BI alongside lakehouse, warehouse and pipeline workloads. Upstream, Power BI usually reads from a warehouse or lakehouse such as SQL Server, Azure SQL, Snowflake or Databricks, and a recurring design question is how much logic belongs there rather than in Power Query or DAX. The working split: shared, governed transformation upstream; calculation that must respond to the reader in DAX; Power Query for the shaping only one model needs.

explore

report an issue with this guide →

questions

page 1 of 2

In Power BI, when should a calculation be a calculated column instead of a DAX measure?

level: juniorimportance: must knowfreq 85%

answer

  1. one is stored, one is not
  2. ask when the value gets computed
  3. slicers need values that already exist
  4. refresh time versus query time
  5. a stored percentage cannot be summed

basics

~20 s

Use a calculated column when the value must physically exist per row — for slicers, axes, grouping or relationship keys. Use a measure for anything aggregated, because measures are computed at query time and store nothing in the model.

solid answer

~50 s

A **calculated column** is evaluated once per row when the model refreshes and is stored in the table, so it costs memory and refresh time but can be used anywhere a real column can: on a slicer, on an axis, as a grouping field, or as a relationship key. A **measure** is not stored at all — it is evaluated at query time against whatever the visual is filtering, so it re-computes correctly at every level, including totals. The rule of thumb: if the value describes a row (a price band, a flag, a concatenated key), it is a column; if it aggregates rows (sales, margin %, distinct customers), it is a measure. Writing `Margin % = SUM(Sales[Profit]) / SUM(Sales[Revenue])` as a column is the classic mistake — a stored per-row ratio cannot be summed back up. Where possible, push column logic upstream into Power Query or the source rather than materialising it in DAX.

code

dax · 7 lines
dax
-- calculated column: one stored value per product row
Product[Price Band] =
    IF ( Product[ListPrice] > 100, "High", "Low" )

-- measure: no stored value, re-evaluated per visual cell
Margin % =
    DIVIDE ( SUM ( Sales[Profit] ), SUM ( Sales[Revenue] ) )

go deeper

for a junior

Be ready to state the rule cleanly: per-row value that users slice by means a column, aggregation means a measure. Know that a calculated column is stored and a measure is not.

for a middle

Explain the mechanics: calculated columns evaluate in row context at refresh and are compressed into VertiPaq; measures evaluate at query time under the visual's filters, which is why they give correct totals.

for a senior

Show the cost judgment. Talk about column cardinality driving model size, pushing column logic upstream to Power Query or the source, and auditing a bloated model for calculated columns that duplicate dimension attributes.

for a principal

Own the standard: where calculation logic lives across the stack, so the same business rule is not implemented three times in SQL, in M and in DAX, and so self-service authors are not materialising fact-table attributes that a star schema already provides.

## Two different objects that both use DAX A Power BI model (the semantic model, called a *dataset* before the Fabric-era rename) holds its tables in VertiPaq, an in-memory columnar engine. DAX can add two very different things to that model, and confusing them is the single most common beginner error in Power BI modelling. A **calculated column** adds a new column to an existing table. It is evaluated **row by row, once, at data-refresh time**, and the result is compressed and stored alongside every other column in the table. It has *row context*: inside the formula, a bare column reference means "this row's value", and `RELATED` can reach across a relationship to fetch the matching row on the one side. A **measure** adds a calculation to the model that has **no stored value at all**. It is evaluated **at query time**, once per cell the visual asks for, against the set of filters that cell is under. A measure has no row context of its own — it must aggregate (`SUM`, `COUNTROWS`, `SUMX`, …), which is why a measure body that references a bare column without an aggregator is an error. ## What that difference implies **Where you can use it.** A slicer, a chart axis, a matrix row header, a legend, a `Group by` field, and the key of a relationship all require *a column* — a real set of values that exists before any query runs. A measure cannot fill any of those roles; it only ever produces a value inside a cell. So if the requirement is "let users slice by price band", the price band must be a calculated column (or, better, a column created upstream). **Cost.** A calculated column consumes model memory and lengthens refresh. The cost is driven by *cardinality*: a low-cardinality column such as a three-value price band compresses to almost nothing, while a per-row calculated key or a per-row timestamp calculation can be one of the largest columns in the model. Calculated columns are also computed after the table is loaded, so they can compress worse than an equivalent column imported from the source. Measures cost nothing at rest; they cost CPU at query time. **Correctness at totals.** This is the deciding argument for ratios. If `Margin %` is stored per row, a matrix total can only aggregate those stored numbers — summing percentages is meaningless, and averaging them weights a one-dollar order the same as a million-dollar order. As a measure, `DIVIDE(SUM(Sales[Profit]), SUM(Sales[Revenue]))` re-evaluates at every grain, including the total row, and produces the correct weighted figure everywhere. ## The upstream option A third answer beats both in many interviews: do it in **Power Query** or in the source view. A column produced upstream is materialised the same way as any imported column, often compresses better, keeps DAX in the model simple, and (when the source is a database) can fold into SQL. Reserve calculated columns for logic that genuinely depends on the model — for example a value that needs `RELATED` across a relationship that only exists in Power BI, or a column derived from another calculated column. ## Worked contrast Given a `Sales` table with `Revenue` and `Profit`, and a `Product` table joined one-to-many to it: - `Product[Price Band] = IF(Product[ListPrice] > 100, "High", "Low")` — a calculated column. It is an attribute of a product, it has three possible values, it belongs on a slicer. - `Sales[Product Category] = RELATED(Product[Category])` — a calculated column that *works* but is usually a waste: the relationship already lets any visual group `Sales` measures by `Product[Category]`. Copying the attribute onto the fact table just spends memory and defeats the star schema. - `Total Profit = SUM(Sales[Profit])` and `Margin % = DIVIDE([Total Profit], SUM(Sales[Revenue]))` — measures. They must respond to whatever the user filtered. ## What interviewers listen for A strong answer names three axes — *when it is evaluated*, *whether it is stored*, and *where it can be used* — and then states the ratio-at-totals failure as the concrete consequence. A weaker answer describes them as two syntaxes for the same thing, or reaches for a calculated column first because it feels more like a spreadsheet. Mentioning that most calculated columns should have been created upstream is what separates a modeller from someone who only writes formulas.

  • Why can't you fix a wrong total by writing the ratio as a calculated column?
    Because a stored per-row ratio is just a number in a column, and the total row can only aggregate those numbers. Summing percentages is meaningless and averaging them weights every row equally. The correct total needs the ratio recomputed from summed numerator and denominator at the total grain, which only a query-time measure does.
  • When is a calculated column the wrong choice even though the value is per-row?
    When the source or Power Query can produce it. An upstream column usually compresses better, refreshes faster, keeps model DAX small, and can fold to SQL against a database. Reserve DAX calculated columns for logic that depends on the model itself, such as a value fetched with RELATED across a relationship that exists only in Power BI.
  • What does high cardinality do to the cost of a calculated column?
    VertiPaq compresses columns by their distinct values, so a three-value flag is nearly free while a per-row key, timestamp or computed decimal can become one of the largest objects in the model. Before adding a high-cardinality calculated column, check whether a measure or an upstream, lower-cardinality column would do.

A calculated column is like adding a column to a spreadsheet and filling it down once; a measure is like a formula in a summary cell that recalculates for whatever range you are currently looking at.

  • Treats calculated columns and measures as interchangeable syntax
  • Stores a ratio like margin percent as a calculated column
  • Ignores memory and refresh cost of high-cardinality calculated columns
  • Thinks a measure can be dropped onto a slicer
  • Never considers building the column upstream in Power Query

Power BI Desktop; the published model is now called a semantic model (formerly dataset) in the Fabric-era Service

context

open as a page

In Power Query, how does Merge Queries differ from Append Queries?

level: juniorimportance: must knowfreq 70%

basics

~20 s

Merge Queries joins two Power Query queries side by side on matching key columns, producing a wider table. Append Queries stacks their rows, producing a taller table. Merge is a SQL-style join; Append behaves like UNION ALL.

open as a page

In a Power BI report, what happens to other visuals when you click a bar in one chart?

level: juniorimportance: must knowfreq 72%

basics

~20 s

By default the clicked point cross-highlights the page: other charts keep their full bars but shade the selected share, while tables, matrices and cards are filtered outright. Edit interactions sets each target visual to Filter, Highlight or None.

open as a page

When you publish a Power BI Desktop file to a workspace, what items appear in the Service?

level: juniorimportance: must knowfreq 70%

basics

~10 s

Publishing a .pbix creates two workspace items: the report (pages and visuals) and the semantic model (queries, relationships, DAX and imported data). A file that live-connects to an existing model publishes the report only.

open as a page

In Power BI, what do a relationship's cardinality and cross-filter direction control?

level: middleimportance: must knowfreq 75%

basics

~20 s

Cardinality declares which side of the relationship holds unique key values; cross-filter direction declares which way a filter travels along it. A one-to-many relationship filters from the one side down to the many side, and by default not back.

open as a page

In DAX, how does a CALCULATE filter argument combine with the visual's existing filters?

level: middleimportance: must knowfreq 80%

basics

~20 s

A boolean filter argument in CALCULATE replaces any existing filter on the same column rather than intersecting with it, while leaving filters on other columns intact. Wrap it in KEEPFILTERS to intersect instead of overwrite.

open as a page

In DAX, what is the difference between row context and filter context?

level: middleimportance: must knowfreq 85%

basics

~20 s

Filter context is the set of filters restricting which model rows a DAX expression sees; it comes from visuals, slicers and CALCULATE. Row context is a pointer to one current row inside a calculated column or an iterator, and it does not filter anything by itself.

open as a page

In Power Query, what is query folding and which steps typically break it?

level: middleimportance: must knowfreq 80%

basics

~20 s

Query folding is Power Query translating Applied Steps into a single native query the source executes, so filtering and aggregation happen at the source. Steps M cannot translate — an index column, Table.Buffer, cross-source merges — end folding, and everything after runs locally.

open as a page

In Power BI, what filters a drill-through page when a reader right-clicks a data point?

level: middleimportance: must knowfreq 60%

basics

~20 s

The values of the fields placed in the target page's drill-through well, taken from the clicked data point. With Keep all filters on, the source visual's other filters travel too, so the detail page matches the context the reader came from.

open as a page

In Power BI, how does dynamic RLS use USERPRINCIPALNAME() to filter rows per user?

level: middleimportance: must knowfreq 68%

basics

~20 s

One role filters a user-mapping table with [UserEmail] = USERPRINCIPALNAME(), which returns the signed-in user's UPN. That row set propagates through relationships to the dimensions and facts, so a single role serves every user and permissions become refreshable data.

open as a page

In Power BI, what does a row-level security role do to the data a report user sees?

level: middleimportance: must knowfreq 75%

basics

~20 s

A Power BI role holds a DAX boolean filter on one or more tables. The engine applies it to every query the assigned user runs and propagates it along relationships, so excluded rows never reach visuals, totals or exports.

open as a page

When does a Power BI scheduled refresh require an on-premises data gateway?

level: middleimportance: must knowfreq 72%

basics

~20 s

A gateway is needed whenever the Power BI Service cannot reach the source directly — anything on-premises or inside a private network. Cloud sources reachable over the public internet refresh without one. DirectQuery and live connections to on-prem sources need the standard gateway.

open as a page

In DAX, what does DIVIDE do that the / operator does not?

level: juniorimportance: should knowfreq 55%

basics

~20 s

DIVIDE is DAX's safe division function: when the denominator is zero or blank it returns BLANK, or an alternate result you pass as the third argument. The / operator instead yields Infinity or NaN, which then leaks into the visual.

open as a page

In Power BI Desktop, how do you check what an RLS role sees before publishing?

level: juniorimportance: should knowfreq 42%

basics

~20 s

Use Desktop's View as feature to render the report under a chosen role, and for dynamic RLS also as another user by typing their UPN. After publishing, the semantic model's security page in the Power BI Service can test the report as a role.

open as a page

In Power BI, why does a matrix show a (Blank) row for a dimension attribute?

level: middleimportance: should knowfreq 50%

basics

~20 s

Power BI adds a hidden blank row to the one side of a relationship when the fact table contains key values that have no match, or nulls. Those fact rows are grouped under (Blank) so the total still includes them.

open as a page

In DAX, why is SUMX(Sales, Sales[Qty] * Sales[Price]) not SUM(Sales[Qty]) * SUM(Sales[Price])?

level: middleimportance: should knowfreq 65%

basics

~20 s

SUMX multiplies quantity by price inside each row and then adds the results, so every row uses its own price. Multiplying two SUMs multiplies a total quantity by a total price, which is a number no transaction ever had.

open as a page

In Power Query, how do you turn a parameterized query into a reusable M function?

level: middleimportance: should knowfreq 42%

basics

~20 s

Wrap the query's let expression in an M lambda — (p as text) as table => let … in … — or use Create Function on a query driven by parameters. Invoking it per row adds a table column you expand, and each row is a separate source call.

open as a page

In Power Query, what happens when a Changed Type step hits an unconvertible value?

level: middleimportance: should knowfreq 55%

basics

~20 s

That single cell becomes an Error value rather than failing the query; surrounding rows load normally. A step-level failure is different — a missing or renamed column aborts the whole query. Handle cell errors explicitly with try/otherwise, Replace Errors or Remove Errors.

open as a page

In Power BI, what report state does a bookmark capture when you save it?

level: middleimportance: should knowfreq 45%

basics

~20 s

A Power BI bookmark saves the page's current state — filter and slicer selections, cross-highlight selection, sort order, drill level, and which visuals are shown or hidden — so a button can restore it. It stores no data; visuals re-query the model when applied.

open as a page

In Power BI, when should you distribute content as an app rather than sharing reports directly?

level: middleimportance: should knowfreq 58%

basics

~20 s

Use a Power BI app once an audience is larger than a handful or the content is finished: it packages chosen workspace items into a stable read-only experience with its own audiences. Direct share links suit ad-hoc, one-off access and sprawl badly at scale.

open as a page

In Power BI, what goes wrong when you set a relationship's cross-filter direction to Both?

level: seniorimportance: should knowfreq 65%

basics

~20 s

Bidirectional filtering lets filters travel back up from the fact table, which can create more than one route between tables, make results depend on the path taken, slow queries, and interact badly with row-level security. Scope it per measure instead.

open as a page

In Power BI, when should you use a bridge table instead of a many-to-many cardinality relationship?

level: seniorimportance: should knowfreq 55%

basics

~20 s

Use a bridge table whenever you need strong relationships, a slicer over the shared keys, or reliable totals. Power BI's many-to-many cardinality creates a limited relationship: no blank row for unmatched keys, no RELATED, and totals that can stop matching the visible rows.

open as a page

In DAX, why does SAMEPERIODLASTYEAR return blank or wrong values without a proper date table?

level: seniorimportance: should knowfreq 50%

basics

~20 s

DAX time-intelligence functions shift a set of dates and reapply it as a filter, which requires a dedicated date table with one row per contiguous calendar day, related to the fact table and marked as a date table. Gaps, duplicates, or filtering the fact table's own date column break the shift.

open as a page

In a Power BI matrix, why doesn't a DAX measure's total row equal the sum of the rows?

level: seniorimportance: should knowfreq 60%

basics

~20 s

The total is not a sum of the displayed cells. Power BI evaluates the same DAX measure again in the total's filter context, with the row grouping removed, so any non-additive measure — a ratio, a distinct count, a conditional — legitimately returns something else.

open as a page

A Power BI report page takes 30 seconds to render — how do you find which visual is responsible?

level: seniorimportance: should knowfreq 50%

basics

~20 s

Run 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.

open as a page

A Power BI RLS role filters DimRegion, yet the fact table still shows every row — why?

level: seniorimportance: should knowfreq 48%

basics

~20 s

The security filter only travels where model relationships carry it. Look for a missing, inactive or wrongly directed relationship, a fact table joined to a different dimension copy, or a disconnected table — and confirm the user is not exempt through workspace edit rights.

open as a page

In the Power BI Service, which users bypass RLS on a semantic model, and why?

level: seniorimportance: should knowfreq 45%

basics

~20 s

Users with workspace Admin, Member or Contributor roles hold edit permission on the semantic model, and RLS is not applied to them. Roles restrict read-only consumers — Viewers and app audiences — and a read-only user assigned to no role sees no data.

open as a page

A Power BI refresh reports success but the dashboard still shows yesterday's numbers — how do you diagnose it?

level: seniorimportance: should knowfreq 50%

basics

~20 s

Check what actually refreshed and when the source was ready. Common causes: you refreshed a different semantic model, incremental refresh touched only recent partitions, the upstream load finished after the schedule fired, or a cached dashboard tile lags the report.

open as a page

When should transformation logic live in Power Query rather than upstream SQL or DAX?

level: principalimportance: should knowfreq 33%

basics

~20 s

Keep in Power Query only shaping that is local to one model or reachable only through a connector — folders of files, APIs, unpivoting. Shared, expensive or auditable logic belongs upstream in the warehouse; logic that must react to user filters belongs in DAX.

open as a page

How would you structure Power BI workspaces and promotion for a shared semantic model used by many teams?

level: principalimportance: should knowfreq 38%

basics

~20 s

Separate the governed semantic model into its own workspace with tight write access and Build permission for analysts, keep team reports in their own workspaces live-connected to it, promote changes through dev/test/prod stages, and endorse the model so people find the right one.

open as a page

showing 1–30 of 36