If you've been developing Power BI reports for a while, you've probably experienced the pain of repetitive work: formatting 50 measures the same way, updating descriptions across multiple tables, or trying to maintain consistency across a large semantic model. The good news? Power BI has powerful metadata tools that can turn hours of tedious work into minutes of strategic edits.
This guide focuses on the advanced techniques that separate good Power BI developers from great ones: working with metadata, bulk operations, and automation strategies that scale.
Every Power BI report contains two layers of information:
The data itself: What users see in visuals
Metadata: Information about the data—measure definitions, formatting rules, relationships, hidden properties, and more
Most developers only interact with metadata through the GUI, clicking through endless menus to make changes one at a time. But Power BI's metadata is accessible through text files (TMDL), DAX queries, and even JSON. Once you learn to work with metadata directly, you unlock capabilities that simply aren't possible through point-and-click interfaces.
TMDL (Tabular Model Definition Language) is a human-readable text format for Power BI semantic models. When you enable TMDL view (still in preview), you can view and edit your entire data model as structured text files.
With TMDL, you can:
1. Bulk Edit Measure Properties
Instead of clicking through the GUI to update 50 measure descriptions, you can:
Define all measures in a table as text
Use find & replace to update patterns
Copy the text to an LLM to generate missing descriptions
Paste back and apply changes
2. Copy/Paste Entire Components
Need that calculation group from another report? Just:
Right-click the calculation group in TMDL view
Copy the entire definition
Paste into your new report's TMDL view
Hit "Apply"
No manual recreation, no missing properties, no errors.
3. Modify Hidden Properties
Some properties don't have GUI options. For example, IsAvailableInMDX can only be modified through TMDL or external tools like Tabular Editor. With TMDL view, you can change these properties directly in Power BI Desktop.
4. Enable Asynchronous Development
Multiple developers working on the same report? Each person can work on their measures in TMDL view, and you can merge them together without conflicts—just like merging code branches.
Here's a real-world scenario: You need to add a standard prefix to all measures in a table.
The Old Way (30+ minutes):
Click each measure
Click in the name field
Add the prefix
Press Enter
Repeat 50 times
The TMDL Way (2 minutes):
Open TMDL view
Right-click the table → "Define all measures"
Use Ctrl+D for multi-cursor editing
Add the prefix to all measure names simultaneously
Click "Update model with changes"
Done.
The DAX Query View isn't just for writing queries—it's a powerful tool for working with semantic model metadata.
Power BI includes special INFO functions that return metadata.
For example INFO.VIEW.MEASURES() returns every measure in your model as a table, including:
Measure name
Table name
Expression
Format string
Description
Display folder
Hidden status
And more
You can filter, sort, and analyze this metadata just like any other data:
EVALUATEFILTER(INFO.VIEW.MEASURES(),[IsHidden] = FALSE && [Description] = "")
This query finds all visible measures missing descriptions—perfect for cleanup.
Need to profile data in your semantic model? Right-click any table in DAX Query View and select "Show column statistics." This generates a complex DAX query that returns:
Row counts
Null counts
Distinct values
Minimums and maximums
Percentile distributions (for dates)
All without writing a single line of code.
When you're connected to a semantic model published to the Power BI Service, you lose the ability to see the Table view in Power BI Desktop. But DAX Query View still works:
EVALUATE TOPN(100, 'DimEmployee')This lets you browse data in the semantic model even when building thin reports.
Want to update multiple measures? Use DAX Query View:
Right-click a table → "Quick queries" → "Define all measures in this table"
The query returns all measure definitions as text
Edit the definitions (find & replace, add calculations, etc.)
Click "Update model with changes"
This is dramatically faster than a manual approach for pure measure updates because you can see all expressions at once and use standard text editing tools.
While everyone knows about Model View for creating relationships, few people leverage its bulk editing capabilities.
In Model View (and ONLY in Model View), you can:
Multi-select fields by holding Ctrl and clicking
Apply properties to all selected fields simultaneously:
Hide/unhide
Change formatting
Turn off default summarization
Change data types
Add to folders
Format all dates consistently:
Click in the search box and type "date"
Ctrl+Click each date field
Choose a date format
All dates now have consistent formatting
Hide all key fields:
Search for "key"
Select all key fields
Click "Hide"
Keys are now hidden from end users
This works for any pattern: amounts that need currency formatting, percentages that need % symbols, IDs that should be hidden, etc.
Here's a technique that saves hours over the course of a project:
Create a "Data Source" group in Power Query with disabled queries for each source table. These queries:
Contain ALL columns (nothing removed)
Have NO filters applied
Are set to "Disable Load" so they don't add overhead
Why? Because now you have instant access to the full source data for exploration:
Sort and filter without writing SQL
Check distinct values
Find min/max values
Test assumptions
Profile data
And because they're disabled, they don't slow down your model or refreshes.
Want to see what's in a database without writing queries? Connect to the database in Power Query, and you'll see a table of all tables, views, and functions. Click any row to preview its data.
This is faster than SQL Management Studio for quick exploration and doesn't require any code.
Calculation groups are one of Power BI's most powerful features, but they're also one of the most underutilized. For fast development, calculation groups shine in two areas:
Instead of creating YTD, MTD, QTD, YoY, etc. versions of every measure, create a calculation group once:
// Time Intelligence Calculation GroupIF (SELECTEDVALUE ( 'Time Calculations'[Calculation] ) = "YTD",CALCULATE ( SELECTEDMEASURE(), DATESYTD ( 'Calendar'[Date] ) ),SELECTEDVALUE ( 'Time Calculations'[Calculation] ) = "YoY",VAR PY = CALCULATE ( SELECTEDMEASURE(), SAMEPERIODLASTYEAR ( 'Calendar'[Date] ) )RETURN DIVIDE ( SELECTEDMEASURE() - PY, PY ),// ... more calculationsSELECTEDMEASURE())
Now any measure can be instantly viewed as YTD, YoY, etc. by selecting from the calculation group slicer.
Create a formatting calculation group to control display format dynamically:
// Format Calculation GroupIF (SELECTEDVALUE ( 'Format'[Format Type] ) = "$ Thousands",DIVIDE ( SELECTEDMEASURE(), 1000 ),SELECTEDVALUE ( 'Format'[Format Type] ) = "$ Millions",DIVIDE ( SELECTEDMEASURE(), 1000000 ),SELECTEDMEASURE())
Combined with format strings, this lets end users toggle between thousands, millions, percentages, etc. without creating duplicate measures.
As of September 2025, DAX supports user-defined functions (UDFs). This is a game-changer for maintenance.
You have a complex calculation used in 20 measures:
Measure 1 =VAR ComplexLogic =CALCULATE([Sales],FILTER(ALL('Date'), 'Date'[FiscalYear] = MAX('Date'[FiscalYear])),FILTER('Product', 'Product'[Category] = "Electronics"))RETURN ComplexLogic / [Total Sales]Measure 2 =VAR ComplexLogic =CALCULATE([Sales],FILTER(ALL('Date'), 'Date'[FiscalYear] = MAX('Date'[FiscalYear])),FILTER('Product', 'Product'[Category] = "Electronics"))RETURN ComplexLogic / [Total Units]// ... 18 more measures with the same logic
Now you need to change the logic. You have to update 20 measures individually.
Create a function once:
FUNCTION CurrentFiscalYearElectronics() =CALCULATE([Sales],FILTER(ALL('Date'), 'Date'[FiscalYear] = MAX('Date'[FiscalYear])),FILTER('Product', 'Product'[Category] = "Electronics"))Measure 1 = CurrentFiscalYearElectronics() / [Total Sales]Measure 2 = CurrentFiscalYearElectronics() / [Total Units]// ... 18 more measures
Now when you need to change the logic, you change it once in the function definition. All 20 measures update automatically.
Many of Power BI's text editors don't support find & replace. But there's a workaround: Ctrl+D for multi-cursor editing.
Here's how it works:
Select one instance of the text you want to change
Press Ctrl+D repeatedly until all instances are highlighted
Start typing to replace all instances simultaneously
This works in TMDL view, DAX Query View, and even M code editors.
Here's how an advanced Power BI developer approaches a new project:
Start with standards: Document naming conventions, calculation patterns, and formatting rules in Markdown
Build the template: Create theme file, template report, and populate with calculation groups and reusable functions
Set up Power Query: Create Data Source group, add custom functions, configure incremental refresh
Build semantic model: Use TMDL view to copy/paste calculation groups from previous projects
Create base measures: Use DAX UDFs for complex logic, organize in folders
Bulk apply properties: Use Model View to format consistently, hide keys, organize folders
Build interface: Use template page, component library, and multi-object editing
Review with metadata: Use INFO functions to find measures without descriptions, check for unused columns
Optimize: Use external tools (Tabular Editor BPA, DAX Studio, Measure Killer)
Document: Generate metadata tables for data dictionary
At every stage, the focus is on working with metadata, not just data. This approach scales to large models with hundreds of measures and dozens of tables.
These advanced techniques have a learning curve. TMDL view can be intimidating if you've never worked with structured text. DAX Query View requires understanding DAX at a deeper level. Report.json editing requires JSON knowledge.
But the investment pays off. Once you're comfortable with these tools, you can accomplish in minutes what used to take hours. You can maintain consistency across large projects. You can work asynchronously with team members. And you can leverage AI tools effectively because you can provide them with structured metadata to work with.
You don't have to master everything at once. Pick one technique that solves a current pain point:
Spending too much time formatting measures? Learn Model View multi-select
Need to copy calculation groups between projects? Learn TMDL view
Want to find measures without descriptions? Learn INFO functions in DAX Query View
Frustrated by repetitive updates? Learn Ctrl+D multi-cursor editing
Master one technique, then add the next. Over time, you'll build a toolkit of advanced capabilities that make you dramatically more productive.
And when you're working faster with better quality, everyone wins: you, your team, and your clients.