Skip to main content
affpapa.org
RU EN
rule official · GitHub

power-bi-dax-best-practices — GitHub Copilot rule: what it does

Instructs GitHub Copilot to write performant DAX code for .pbix, .dax, .md, and .txt files. It enforces Microsoft conventions for syntax and calculations.

Install into GitHub Copilot · Manually: put the files in place All methods and platforms ↓ 
.github/instructions/power-bi-dax-best-practices.instructions.md
Open on GitHub

What power-bi-dax-best-practices does

This rule directs the coding assistant to follow Microsoft guidance when building Power BI measures. Copilot stores intermediate computations inside VAR blocks rather than repeating complex expressions. That guarantees single evaluation and keeps queries fast. For table row counts, it picks COUNTROWS instead of COUNT.

Naming syntax follows strict conventions. Column references always include the table name, such as Sales[CustomerID]. Measures stay unqualified so moving them between tables will not break existing code. For error prevention, the rule insists on DIVIDE and bans IFERROR functions because they slow down formula engines.

The prompt package covers common calculations, including time intelligence like DATESYTD, moving averages, and Pareto ABC classification. Adding calculated columns to large tables causes high memory overhead. Because of that, the rule explicitly demands preparing row-level transforms in Power Query.

What it helps with

  • prevent performance degradation from IFERROR and ISERROR functions
  • format measure and column references according to Microsoft syntax
  • reuse calculations with cached VAR variables
  • build time intelligence measures like YTD and moving averages

Example prompts for the agent

  • Write a YoY sales growth measure in DAX using VAR variables.
  • Create a 3-month moving average measure for Sales with DATESBETWEEN.
  • Generate an ABC Pareto classification measure using SWITCH and running totals.

How to install power-bi-dax-best-practices

Manually: put the files in place

.github/instructions/power-bi-dax-best-practices.instructions.md

The applyTo field sets which files it applies to

Step by step, with commands for each platform: AGENTS.md vs CLAUDE.md: what they are and which one to use

Questions about power-bi-dax-best-practices

How do I install power-bi-dax-best-practices in GitHub Copilot?

Save the rule file to .github/instructions/power-bi-dax-best-practices.instructions.md in your repository. GitHub Copilot will apply its guidelines when editing .pbix, .dax, .md, or .txt files.

What does power-bi-dax-best-practices do?

It guides the assistant to write optimized DAX formulas following Microsoft patterns. It enforces safe division via DIVIDE, formats column and measure references, and sets up efficient filtering in CALCULATE.

Why does the rule ban the IFERROR function?

Functions like IFERROR and ISERROR force the engine into costly checks that degrade execution speed. The rule mandates using the native DIVIDE function instead to handle zero division.

Source text

power-bi-dax-best-practices.instructions.md · MIT 
---
description: 'Comprehensive Power BI DAX best practices and patterns based on Microsoft guidance for creating efficient, maintainable, and performant DAX formulas.'
applyTo: '**/*.{pbix,dax,md,txt}'
---

# Power BI DAX Best Practices

## Overview
This document provides comprehensive instructions for writing efficient, maintainable, and performant DAX (Data Analysis Expressions) formulas in Power BI, based on Microsoft's official guidance and best practices.

## Core DAX Principles

### 1. Formula Structure and Variables
Always use variables to improve performance, readability, and debugging:

```dax
// ✅ PREFERRED: Using variables for clarity and performance
Sales YoY Growth % =
VAR CurrentSales = [Total Sales]
VAR PreviousYearSales = 
    CALCULATE(
        [Total Sales],
        SAMEPERIODLASTYEAR('Date'[Date])
    )
RETURN
    DIVIDE(CurrentSales - PreviousYearSales, PreviousYearSales)

// ❌ AVOID: Repeated calculations without variables  
Sales YoY Growth % =
DIVIDE(
    [Total Sales] - CALCULATE([Total Sales], SAMEPERIODLASTYEAR('Date'[Date])),
    CALCULATE([Total Sales], SAMEPERIODLASTYEAR('Date'[Date]))
)
```

**Key Benefits of Variables:**
- **Performance**: Calculations are evaluated once and cached
- **Readability**: Complex formulas become self-documenting
- **Debugging**: Can temporarily return variable values for testing
- **Maintainability**: Changes need to be made in only one place

### 2. Proper Reference Syntax
Follow Microsoft's recommended patterns for column and measure references:

```dax
// ✅ ALWAYS fully qualify column references
Customer Count = 
DISTINCTCOUNT(Sales[CustomerID])

Profit Margin = 
DIVIDE(
    SUM(Sales[Profit]),
    SUM(Sales[Revenue])
)

// ✅ NEVER fully qualify measure references
YTD Sales Growth = 
DIVIDE([YTD Sales] - [YTD Sales PY], [YTD Sales PY])

// ❌ AVOID: Unqualified column references
Customer Count = DISTINCTCOUNT([CustomerID])  // Ambiguous

// ❌ AVOID: Fully qualified measure references
Growth Rate = DIVIDE(Sales[Total Sales] - Sales[Total Sales PY], Sales[Total Sales PY])  // Breaks if measure moves
```

### 3. Error Handling Strategies
Implement robust error handling using appropriate patterns:

```dax
// ✅ PREFERRED: Use DIVIDE function for safe division
Profit Margin = 
DIVIDE([Total Profit], [Total Revenue])

// ✅ PREFERRED: Use defensive strategies in model design
Average Order Value = 
VAR TotalOrders = COUNTROWS(Orders)
VAR TotalRevenue = SUM(Orders[Amount])
RETURN
    IF(TotalOrders > 0, DIVIDE(TotalRevenue, TotalOrders))

// ❌ AVOID: ISERROR and IFERROR functions (performance impact)
Profit Margin = 
IFERROR([Total Profit] / [Total Revenue], BLANK())

// ❌ AVOID: Complex error handling that could be prevented
Unsafe Calculation = 
IF(
    OR(
        ISBLANK([Revenue]),
        [Revenue] = 0
    ),
    BLANK(),
    [Profit] / [Revenue]
)
```

## DAX Function Categories and Best Practices

### Aggregation Functions
```dax
// Use appropriate aggregation functions for performance
Customer Count = DISTINCTCOUNT(Sales[CustomerID])  // ✅ For unique counts
Order Count = COUNTROWS(Orders)                    // ✅ For row counts  
Average Deal Size = AVERAGE(Sales[DealValue])      // ✅ For averages

// Avoid COUNT when COUNTROWS is more appropriate
// ❌ COUNT(Sales[OrderID]) - slower for counting rows
// ✅ COUNTROWS(Sales) - faster and more explicit
```

### Filter and Context Functions
```dax
// Efficient use of CALCULATE with multiple filters
High Value Customers = 
CALCULATE(
    DISTINCTCOUNT(Sales[CustomerID]),
    Sales[OrderValue] > 1000,
    Sales[OrderDate] >= DATE(2024,1,1)
)

// Proper context modification patterns
Same Period Last Year = 
CALCULATE(
    [Total Sales],
    SAMEPERIODLASTYEAR('Date'[Date])
)

// Using FILTER appropriately (avoid as filter argument)
// ✅ PREFERRED: Direct filter expression
High Value Orders = 
CALCULATE(
    [Total Sales],
    Sales[OrderValue] > 1000
)

// ❌ AVOID: FILTER as filter argument (unless table manipulation needed)
High Value Orders = 
CALCULATE(
    [Total Sales],
    FILTER(Sales, Sales[OrderValue] > 1000)
)
```

### Time Intelligence Patterns
```dax
// Standard time intelligence measures
YTD Sales = 
CALCULATE(
    [Total Sales],
    DATESYTD('Date'[Date])
)

MTD Sales = 
CALCULATE(
    [Total Sales],
    DATESMTD('Date'[Date])
)

// Moving averages with proper date handling
3-Month Moving Average = 
VAR CurrentDate = MAX('Date'[Date])
VAR StartDate = EDATE(CurrentDate, -2)
RETURN
    CALCULATE(
        DIVIDE([Total Sales], 3),
        DATESBETWEEN(
            'Date'[Date],
            StartDate,
            CurrentDate
        )
    )

// Quarter over quarter growth
QoQ Growth = 
VAR CurrentQuarter = [Total Sales]
VAR PreviousQuarter = 
    CALCULATE(
        [Total Sales],
        DATEADD('Date'[Date], -1, QUARTER)
    )
RETURN
    DIVIDE(CurrentQuarter - PreviousQuarter, PreviousQuarter)
```

### Advanced DAX Patterns
```dax
// Ranking with proper context
Product Rank = 
RANKX(
    ALL(Product[ProductName]),
    [Total Sales],
    ,
    DESC,
    DENSE
)

// Running totals
Running Total = 
CALCULATE(
    [Total Sales],
    FILTER(
        ALL('Date'[Date]),
        'Date'[Date] <= MAX('Date'[Date])
    )
)

// ABC Analysis (Pareto)
ABC Classification = 
VAR CurrentProductSales = [Total Sales]
VAR TotalSales = CALCULATE([Total Sales], ALL(Product))
VAR RunningTotal = 
    CALCULATE(
        [Total Sales],
        FILTER(
            ALL(Product),
            [Total Sales] >= CurrentProductSales
        )
    )
VAR PercentageOfTotal = DIVIDE(RunningTotal, TotalSales)
RETURN
    SWITCH(
        TRUE(),
        PercentageOfTotal <= 0.8, "A",
        PercentageOfTotal <= 0.95, "B",
        "C"
    )
```

## Performance Optimization Techniques

### 1. Efficient Variable Usage
```dax
// ✅ Store expensive calculations in variables
Complex Measure = 
VAR BaseCalculation = 
    CALCULATE(
        SUM(Sales[Amount]),
        FILTER(
            Product,
            Product[Category] = "Electronics"
        )
    )
VAR PreviousYear = 
    CALCULATE(
        BaseCalculation,
        SAMEPERIODLASTYEAR('Date'[Date])
    )
RETURN
    DIVIDE(BaseCalculation - PreviousYear, PreviousYear)
```

### 2. Context Transition Optimization
```dax
// ✅ Minimize context transitions in iterator functions
Total Product Profit = 
SUMX(
    Product,
    Product[UnitPrice] - Product[UnitCost]
)

// ❌ Avoid unnecessary calculated columns in large tables
// Create in Power Query instead when possible
```

### 3. Efficient Filtering Patterns
```dax
// ✅ Use table expressions efficiently
Top 10 Customers = 
CALCULATE(
    [Total Sales],
    TOPN(
        10,
        ALL(Customer[CustomerName]),
        [Total Sales]
    )
)

// ✅ Leverage relationship filtering
Sales with Valid Customers = 
CALCULATE(
    [Total Sales],
    FILTER(
        Customer,
        NOT(ISBLANK(Customer[CustomerName]))
    )
)
```

## Common DAX Anti-Patterns to Avoid

### 1. Performance Anti-Patterns
```dax
// ❌ AVOID: Nested CALCULATE functions
Inefficient Nested = 
CALCULATE(
    CALCULATE(
        [Total Sales],
        Product[Category] = "Electronics"
    ),
    'Date'[Year] = 2024
)

// ✅ PREFERRED: Single CALCULATE with multiple filters
Efficient Single = 
CALCULATE(
    [Total Sales],
    Product[Category] = "Electronics",
    'Date'[Year] = 2024
)

// ❌ AVOID: Converting BLANK to zero unnecessarily
Sales with Zero = 
IF(ISBLANK([Total Sales]), 0, [Total Sales])

// ✅ PREFERRED: Keep BLANK as BLANK for better visual behavior
Sales = SUM(Sales[Amount])
```

### 2. Readability Anti-Patterns
```dax
// ❌ AVOID: Complex nested expressions without variables
Complex Without Variables = 
DIVIDE(
    CALCULATE(SUM(Sales[Revenue]), Sales[Date] >= DATE(2024,1,1)) - 
    CALCULATE(SUM(Sales[Revenue]), Sales[Date] >= DATE(2023,1,1), Sales[Date] < DATE(2024,1,1)),
    CALCULATE(SUM(Sales[Revenue]), Sales[Date] >= DATE(2023,1,1), Sales[Date] < DATE(2024,1,1))
)

// ✅ PREFERRED: Clear variable-based structure
Year Over Year Growth = 
VAR CurrentYear = 
    CALCULATE(
        SUM(Sales[Revenue]),
        Sales[Date] >= DATE(2024,1,1)
    )
VAR PreviousYear = 
    CALCULATE(
        SUM(Sales[Revenue]),
        Sales[Date] >= DATE(2023,1,1),
        Sales[Date] < DATE(2024,1,1)
    )
RETURN
    DIVIDE(CurrentYear - PreviousYear, PreviousYear)
```

## DAX Debugging and Testing Strategies

### 1. Variable-Based Debugging
```dax
// Use this pattern for step-by-step debugging
Debug Measure = 
VAR Step1 = CALCULATE([Sales], 'Date'[Year] = 2024)
VAR Step2 = CALCULATE([Sales], 'Date'[Year] = 2023)  
VAR Step3 = Step1 - Step2
VAR Step4 = DIVIDE(Step3, Step2)
RETURN
    -- Return different variables for testing:
    -- Step1  -- Test current year sales
    -- Step2  -- Test previous year sales  
    -- Step3  -- Test difference calculation
    Step4     -- Final result
```

### 2. Testing Patterns
```dax
// Include data validation in measures
Validated Measure = 
VAR Result = [Complex Calculation]
VAR IsValid = 
    Result >= 0 && 
    Result <= 1 && 
    NOT(ISBLANK(Result))
RETURN
    IF(IsValid, Result, BLANK())
```

## Measure Organization and Naming

### 1. Naming Conventions
```dax
// Use descriptive, consistent naming
Total Sales = SUM(Sales[Amount])
Total Sales YTD = CALCULATE([Total Sales], DATESYTD('Date'[Date]))
Total Sales PY = CALCULATE([Total Sales], SAMEPERIODLASTYEAR('Date'[Date]))
Sales Growth % = DIVIDE([Total Sales] - [Total Sales PY], [Total Sales PY])

// Prefix for measure categories
KPI - Revenue Growth = [Sales Growth %]
Calc - Days Since Last Order = DATEDIFF(MAX(Orders[OrderDate]), TODAY(), DAY)
Base - Order Count = COUNTROWS(Orders)
```

### 2. Measure Dependencies
```dax
// Build measures hierarchically for reusability
// Base measures
Revenue = SUM(Sales[Revenue])
Cost = SUM(Sales[Cost])

// Derived measures  
Profit = [Revenue] - [Cost]
Margin % = DIVIDE([Profit], [Revenue])

// Advanced measures
Profit YTD = CALCULATE([Profit], DATESYTD('Date'[Date]))
Margin Trend = [Margin %] - CALCULATE([Margin %], PREVIOUSMONTH('Date'[Date]))
```

## Model Integration Best Practices

### 1. Working with Star Schema
```dax
// Leverage proper relationships
Sales by Category = 
CALCULATE(
    [Total Sales],
    Product[Category] = "Electronics"
)

// Use dimension tables for filtering
Regional Sales = 
CALCULATE(
    [Total Sales],
    Geography[Region] = "North America"
)
```

### 2. Handle Missing Relationships
```dax
// When direct relationships don't exist
Cross Table Analysis = 
VAR CustomerList = VALUES(Customer[CustomerID])
RETURN
    CALCULATE(
        [Total Sales],
        FILTER(
            Sales,
            Sales[CustomerID] IN CustomerList
        )
    )
```

## Advanced DAX Concepts

### 1. Row Context vs Filter Context
```dax
// Understanding context differences
Row Context Example = 
SUMX(
    Sales,
    Sales[Quantity] * Sales[UnitPrice]  // Row context
)

Filter Context Example = 
CALCULATE(
    [Total Sales],  // Filter context
    Product[Category] = "Electronics"
)
```

### 2. Context Transition
```dax
// When row context becomes filter context
Sales Per Product = 
SUMX(
    Product,
    CALCULATE([Total Sales])  // Context transition happens here
)
```

### 3. Extended Columns and Computed Tables
```dax
// Use for complex analytical scenarios
Product Analysis = 
ADDCOLUMNS(
    Product,
    "Total Sales", CALCULATE([Total Sales]),
    "Rank", RANKX(ALL(Product), CALCULATE([Total Sales])),
    "Category Share", DIVIDE(
        CALCULATE([Total Sales]),
        CALCULATE([Total Sales], ALL(Product[ProductName]))
    )
)
```

### 4. Advanced Time Intelligence Patterns
```dax
// Multi-period comparisons with calculation groups
// Example showing how to create dynamic time calculations
Dynamic Period Comparison = 
VAR CurrentPeriodValue = 
    CALCULATE(
        [Sales],
        'Time Intelligence'[Time Calculation] = "Current"
    )
VAR PreviousPeriodValue = 
    CALCULATE(
        [Sales],
        'Time Intelligence'[Time Calculation] = "PY"
    )
VAR MTDCurrent = 
    CALCULATE(
        [Sales],
        'Time Intelligence'[Time Calculation] = "MTD"
    )
VAR MTDPrevious = 
    CALCULATE(
        [Sales],
        'Time Intelligence'[Time Calculation] = "PY MTD"
    )
RETURN
    DIVIDE(MTDCurrent - MTDPrevious, MTDPrevious)

// Working with fiscal years and custom calendars
Fiscal YTD Sales = 
VAR FiscalYearStart = 
    DATE(
        IF(MONTH(MAX('Date'[Date])) >= 7, YEAR(MAX('Date'[Date])), YEAR(MAX('Date'[Date])) - 1),
        7,
        1
    )
VAR FiscalYearEnd = MAX('Date'[Date])
RETURN
    CALCULATE(
        [Total Sales],
        DATESBETWEEN(
            'Date'[Date],
            FiscalYearStart,
            FiscalYearEnd
        )
    )
```

### 5. Advanced Performance Optimization Techniques
```dax
// Optimized running totals
Running Total Optimized = 
VAR CurrentDate = MAX('Date'[Date])
RETURN
    CALCULATE(
        [Total Sales],
        FILTER(
            ALL('Date'[Date]),
            'Date'[Date] <= CurrentDate
        )
    )

// Efficient ABC Analysis using RANKX
ABC Classification Advanced = 
VAR ProductRank = 
    RANKX(
        ALL(Product[ProductName]),
        [Total Sales],
        ,
        DESC,
        DENSE
    )
VAR TotalProducts = COUNTROWS(ALL(Product[ProductName]))
VAR ClassAThreshold = TotalProducts * 0.2
VAR ClassBThreshold = TotalProducts * 0.5
RETURN
    SWITCH(
        TRUE(),
        ProductRank <= ClassAThreshold, "A",
        ProductRank <= ClassBThreshold, "B",
        "C"
    )

// Efficient Top N with ties handling
Top N Products with Ties = 
VAR TopNValue = 10
VAR MinTopNSales = 
    CALCULATE(
        MIN([Total Sales]),
        TOPN(
            TopNValue,
            ALL(Product[ProductName]),
            [Total Sales]
        )
    )
RETURN
    IF(
        [Total Sales] >= MinTopNSales,
        [Total Sales],
        BLANK()
    )
```

### 6. Complex Analytical Scenarios
```dax
// Customer cohort analysis
Cohort Retention Rate = 
VAR CohortMonth = 
    CALCULATE(
        MIN('Date'[Date]),
        ALLEXCEPT(Sales, Sales[CustomerID])
    )
VAR CurrentMonth = MAX('Date'[Date])
VAR MonthsFromCohort = 
    DATEDIFF(CohortMonth, CurrentMonth, MONTH)
VAR CohortCustomers = 
    CALCULATE(
        DISTINCTCOUNT(Sales[CustomerID]),
        'Date'[Date] = CohortMonth
    )
VAR ActiveCustomersInMonth = 
    CALCULATE(
        DISTINCTCOUNT(Sales[CustomerID]),
        'Date'[Date] = CurrentMonth,
        FILTER(
            Sales,
            CALCULATE(
                MIN('Date'[Date]),
                ALLEXCEPT(Sales, Sales[CustomerID])
            ) = CohortMonth
        )
    )
RETURN
    DIVIDE(ActiveCustomersInMonth, CohortCustomers)

// Market basket analysis
Product Affinity Score = 
VAR CurrentProduct = SELECTEDVALUE(Product[ProductName])
VAR RelatedProduct = SELECTEDVALUE('Related Product'[ProductName])
VAR TransactionsWithBoth = 
    CALCULATE(
        DISTINCTCOUNT(Sales[TransactionID]),
        Sales[ProductName] = CurrentProduct
    ) +
    CALCULATE(
        DISTINCTCOUNT(Sales[TransactionID]),
        Sales[ProductName] = RelatedProduct
    ) -
    CALCULATE(
        DISTINCTCOUNT(Sales[TransactionID]),
        Sales[ProductName] = CurrentProduct,
        CALCULATE(
            COUNTROWS(Sales),
            Sales[ProductName] = RelatedProduct,
            Sales[TransactionID] = EARLIER(Sales[TransactionID])
        ) > 0
    )
VAR TotalTransactions = DISTINCTCOUNT(Sales[TransactionID])
RETURN
    DIVIDE(TransactionsWithBoth, TotalTransactions)
```

### 7. Advanced Debugging and Profiling
```dax
// Debug measure with detailed variable inspection
Complex Measure Debug = 
VAR Step1_FilteredSales = 
    CALCULATE(
        [Sales],
        Product[Category] = "Electronics",
        'Date'[Year] = 2024
    )
VAR Step2_PreviousYear = 
    CALCULATE(
        [Sales],
        Product[Category] = "Electronics",
        'Date'[Year] = 2023
    )
VAR Step3_GrowthAbsolute = Step1_FilteredSales - Step2_PreviousYear
VAR Step4_GrowthPercentage = DIVIDE(Step3_GrowthAbsolute, Step2_PreviousYear)
VAR DebugInfo = 
    "Current: " & FORMAT(Step1_FilteredSales, "#,0") & 
    " | Previous: " & FORMAT(Step2_PreviousYear, "#,0") &
    " | Growth: " & FORMAT(Step4_GrowthPercentage, "0.00%")
RETURN
    -- Switch between these for debugging:
    -- Step1_FilteredSales    -- Test current year
    -- Step2_PreviousYear     -- Test previous year
    -- Step3_GrowthAbsolute   -- Test absolute growth
    -- DebugInfo              -- Show debug information
    Step4_GrowthPercentage    -- Final result

// Performance monitoring measure
Query Performance Monitor = 
VAR StartTime = NOW()
VAR Result = [Complex Calculation]
VAR EndTime = NOW()
VAR ExecutionTime = DATEDIFF(StartTime, EndTime, SECOND)
VAR WarningThreshold = 5 // seconds
RETURN
    IF(
        ExecutionTime > WarningThreshold,
        "⚠️ Slow: " & ExecutionTime & "s - " & Result,
        Result
    )
```

### 8. Working with Complex Data Types
```dax
// JSON parsing and manipulation
Extract JSON Value = 
VAR JSONString = SELECTEDVALUE(Data[JSONColumn])
VAR ParsedValue = 
    IF(
        NOT(ISBLANK(JSONString)),
        PATHCONTAINS(JSONString, "$.analytics.revenue"),
        BLANK()
    )
RETURN
    ParsedValue

// Dynamic measure selection
Dynamic Measure Selector = 
VAR SelectedMeasure = SELECTEDVALUE('Measure Selector'[MeasureName])
RETURN
    SWITCH(
        SelectedMeasure,
        "Revenue", [Total Revenue],
        "Profit", [Total Profit],
        "Units", [Total Units],
        "Margin", [Profit Margin %],
        BLANK()
    )
```

## DAX Formula Documentation

### 1. Commenting Best Practices
```dax
/* 
Business Rule: Calculate customer lifetime value based on:
- Average order value over customer lifetime
- Purchase frequency (orders per year)  
- Customer lifespan (years since first order)
- Retention probability based on last order date
*/
Customer Lifetime Value = 
VAR AvgOrderValue = 
    DIVIDE(
        CALCULATE(SUM(Sales[Amount])),
        CALCULATE(DISTINCTCOUNT(Sales[OrderID]))
    )
VAR OrdersPerYear = 
    DIVIDE(
        CALCULATE(DISTINCTCOUNT(Sales[OrderID])),
        DATEDIFF(
            CALCULATE(MIN(Sales[OrderDate])),
            CALCULATE(MAX(Sales[OrderDate])),
            YEAR
        ) + 1  -- Add 1 to avoid division by zero for customers with orders in single year
    )
VAR CustomerLifespanYears = 3  -- Business assumption: average 3-year relationship
RETURN
    AvgOrderValue * OrdersPerYear * CustomerLifespanYears
```

### 2. Version Control and Change Management
```dax
// Include version history in measure descriptions
/*
Version History:
v1.0 - Initial implementation (2024-01-15)
v1.1 - Added null checking for edge cases (2024-02-01)  
v1.2 - Optimized performance using variables (2024-02-15)
v2.0 - Changed business logic per stakeholder feedback (2024-03-01)

Business Logic:
- Excludes returns and cancelled orders
- Uses ship date for revenue recognition
- Applies regional tax calculations
*/
```

## Testing and Validation Framework

### 1. Unit Testing Patterns
```dax
// Create test measures for validation
Test - Sales Sum = 
VAR DirectSum = SUM(Sales[Amount])
VAR MeasureResult = [Total Sales]
VAR Difference = ABS(DirectSum - MeasureResult)
RETURN
    IF(Difference < 0.01, "PASS", "FAIL: " & Difference)
```

### 2. Performance Testing
```dax
// Monitor execution time for complex measures
Performance Monitor = 
VAR StartTime = NOW()
VAR Result = [Complex Calculation]
VAR EndTime = NOW()
VAR Duration = DATEDIFF(StartTime, EndTime, SECOND)
RETURN
    "Result: " & Result & " | Duration: " & Duration & "s"
```

Remember: Always validate DAX formulas with business users to ensure calculations match business requirements and expectations. Use Power BI's Performance Analyzer and DAX Studio for performance optimization and debugging.

© github · MIT · github/awesome-copilot

Similar IDE rules

All IDE rules for Data and databases →

From the same set861

The whole set →
power-platform-connector A GitHub Copilot rule for writing JSON schemas of Power Platform custom connectors: Swagger 2.0, apiProperties and settings. ★ 40,418repo stars power-bi-security-rls-best-practices Power BI Row-Level Security rule for GitHub Copilot. Guides DAX role filtering, embedded analytics security, and Fabric Warehouse policies. ★ 40,418repo stars power-bi-report-design-best-practices This rule guides Power BI chart selection and report layout. Use it when planning a page, navigation, or visual explanations. ★ 40,418repo stars power-bi-devops-alm-best-practices A GitHub Copilot rule that steers the agent through Power BI version control, CI/CD pipelines and multi-stage deployment. ★ 40,418repo stars power-bi-data-modeling-best-practices This rule guides Power BI model design around star schemas. Use it when shaping tables, relationships, filters, and storage modes. ★ 40,418repo stars power-bi-custom-visuals-development A GitHub Copilot rule that gives the agent patterns for building Power BI custom visuals with React, D3.js and TypeScript. ★ 40,418repo stars power-apps-code-apps Guides GitHub Copilot on Power Apps Code Apps standards using TypeScript, React, and Vite. Enforces correct SDK usage, PAC CLI structures, and Power BI embedding. ★ 40,418repo stars power-apps-canvas-yaml This rule guides GitHub Copilot when editing Canvas Apps YAML and Power Fx formulas. Use it to shape screens, controls, components, and data connections. ★ 40,418repo stars

Project sponsors

Companies that keep this analytics open
Gold sponsor
Nutra.Club

Impressions, clicks and code copies — open statistics. We keep the numbers public for the same reason NeBlask itself is public. Become a sponsor