A Comprehensive Guide to Working Faster and Smarter with Power BI

Part 2 of 2: Advanced Power BI Development: Mastering Metadata and Bulk Operations

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.

Why Metadata Matters

Every Power BI report contains two layers of information:

1. The data itself: What users see in visuals

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

The Power of TMDL View

What is TMDL?

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.

Why This Matters

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.

Practical TMDL Workflow

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):

1. Open TMDL view

2. Right-click the table → "Define all measures"

3. Use Ctrl+D for multi-cursor editing

4. Add the prefix to all measure names simultaneously

5. Click "Update model with changes"

Done.

DAX Query View: Your Metadata Swiss Army Knife

The DAX Query View isn't just for writing queries—it's a powerful tool for working with semantic model metadata.

INFO Functions for Metadata Discovery

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:

EVALUATE
FILTER(
    INFO.VIEW.MEASURES(),
    [IsHidden] = FALSE && [Description] = ""
)

This query finds all visible measures missing descriptions—perfect for cleanup.

Column Statistics Without Code

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.

Working with Semantic Models in Service

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.

Mass Measure Updates

Want to update multiple measures? Use DAX Query View:

1. Right-click a table → "Quick queries" → "Define all measures in this table"

2. The query returns all measure definitions as text

3. Edit the definitions (find & replace, add calculations, etc.)

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

Model View: The Underrated Bulk Editor

While everyone knows about Model View for creating relationships, few people leverage its bulk editing capabilities.

Multi-Select Power

In Model View (and ONLY in Model View), you can:

1. Multi-select fields by holding Ctrl and clicking

2. Apply properties to all selected fields simultaneously:

   • Hide/unhide

   • Change formatting

   • Turn off default summarization

   • Change data types

   • Add to folders

Real-World Use Cases

Format all dates consistently:

1. Click in the search box and type "date"

2. Ctrl+Click each date field

3. Choose a date format

4. All dates now have consistent formatting

Hide all key fields:

1. Search for "key"

2. Select all key fields

3. Click "Hide"

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

The Power Query Metadata Advantage

Data Source Groups for Data Discovery

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.

Viewing Database Objects Without Code

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.

Strategic Use of Calculation Groups

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:

Time Intelligence

Instead of creating YTD, MTD, QTD, YoY, etc. versions of every measure, create a calculation group once:

// Time Intelligence Calculation Group
IF (
    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 calculations
    SELECTEDMEASURE()
)

Now any measure can be instantly viewed as YTD, YoY, etc. by selecting from the calculation group slicer.

Formatting

Create a formatting calculation group to control display format dynamically:

// Format Calculation Group
IF (
    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.

Reusable Functions: The New Frontier

As of September 2025, DAX supports user-defined functions (UDFs). This is a game-changer for maintenance.

The Old Way

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.

The UDF Way

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.

The Ctrl+D Secret Weapon

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:

1. Select one instance of the text you want to change

2. Press Ctrl+D repeatedly until all instances are highlighted

3. Start typing to replace all instances simultaneously

This works in TMDL view, DAX Query View, and even M code editors.

Putting It All Together: A Metadata-First Workflow

Here's how an advanced Power BI developer approaches a new project:

1. Start with standards: Document naming conventions, calculation patterns, and formatting rules in Markdown

2. Build the template: Create theme file, template report, and populate with calculation groups and reusable functions

3. Set up Power Query: Create Data Source group, add custom functions, configure incremental refresh

4. Build semantic model: Use TMDL view to copy/paste calculation groups from previous projects

5. Create base measures: Use DAX UDFs for complex logic, organize in folders

6. Bulk apply properties: Use Model View to format consistently, hide keys, organize folders

7. Build interface: Use template page, component library, and multi-object editing

8. Review with metadata: Use INFO functions to find measures without descriptions, check for unused columns

9. Optimize: Use external tools (Tabular Editor BPA, DAX Studio, Measure Killer)

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

The Learning Curve

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.

Start Simple, Build Gradually

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.