RELATEDTABLE

Comprehensive Guide to the RELATEDTABLE DAX Function

Overview

The RELATEDTABLE function is the complement to RELATED and is essential for aggregating data from the "many" side of a relationship when you're working in the "one" side. It returns a table containing all related rows, which can then be used with iterator functions to calculate totals, averages, counts, and other aggregations.

Applies to: Calculated columns, Calculated tables, Measures

Works in: Row context (typically in dimension tables on the "one" side)

Syntax

RELATEDTABLE ( <table> )

Parameters

Parameter	Required	Description	Example
table	Yes	The name of the related table from which you want to retrieve rows	`FactSales`, `FactOrders`, `FactInventory`

Return Value

Returns a table containing all related rows from the specified table based on the current row context.

Understanding How RELATEDTABLE Works

The Relationship Direction Concept

RELATEDTABLE works by following existing relationships in the opposite direction from RELATED:

RELATEDTABLE travels from the ONE side → to the MANY side

Example:
DimProduct (One) ←────────── FactSales (Many)
 ProductKey                    ProductKey

In DimProduct, you can use RELATEDTABLE to get all FactSales rows

Visual Representation:

DimProduct Table (One Side 1)          FactSales Table (Many Side *)
┌──────────────────────┐              ┌──────────────────────┐
│ ProductKey      [PK] │              │ SalesKey         [PK]│
│ Product Name         │  ←────────   │ ProductKey       [FK]│
│ Category             │ RELATEDTABLE │ Quantity             │
│ List Price           │              │ Sales Amount         │
└──────────────────────┘              │ Customer Key         │
                                      └──────────────────────┘

RELATEDTABLE works here ✅
Can get: All sales rows for this product

RELATED vs RELATEDTABLE Comparison

Aspect	RELATED	RELATEDTABLE
Direction	Many → One	One → Many
Used in	Fact tables	Dimension tables
Returns	Single value	Table of rows
Example	Get product name in sales	Get all sales for a product
Common use	Calculated column	Measure with iterator

Basic Examples Using Contoso Data

Example 1: Total Sales per Product

Scenario: Calculate total sales for each product in the product dimension.

Data Model:

DimProduct[ProductKey] ←── FactSales[ProductKey]

DAX Formula:

Total Product Sales =
SUMX(
    RELATEDTABLE( FactSales ),
    FactSales[Sales Amount]
)

Detailed Explanation:

For each row in DimProduct:

Power BI looks at the DimProduct[ProductKey] for the current product
Finds ALL matching rows in FactSales with that ProductKey
Returns a table containing all those sales rows
SUMX iterates through each row and sums the Sales Amount

Example Data Flow:

DimProduct
ProductKey	Product Name	Category
201	Contoso Phone X1	Phones
305	Contoso Laptop Pro	Computers

FactSales
SalesKey	ProductKey	Quantity	Sales Amount
1001	201	5	$250
1002	201	3	$180
1003	305	2	$400
1004	201	1	$50

Step-by-Step Execution for Product 201:

Step 1: Current product has ProductKey = 201

Step 2: RELATEDTABLE( FactSales ) returns:
        ┌─────────────────────────┐
        │ SalesKey | ProductKey | Sales Amount │
        │ 1001     | 201        | $250         │
        │ 1002     | 201        | $180         │
        │ 1004     | 201        | $50          │
        └─────────────────────────┘

Step 3: SUMX iterates through each row:
        $250 + $180 + $50 = $480

Step 4: Returns $480 as Total Product Sales

Result:

DimProduct
ProductKey	Product Name	Category	Total Product Sales
201	Contoso Phone X1	Phones	$480
305	Contoso Laptop Pro	Computers	$400

Example 2: Count of Transactions per Customer

Scenario: Count how many purchases each customer has made.

Data Model:

DimCustomer[CustomerKey] ←── FactSales[CustomerKey]

DAX Formula:

Number of Orders =
COUNTROWS( RELATEDTABLE( FactSales ) )

Example Data:

DimCustomer
CustomerKey	Customer Name	City
1523	John Smith	Seattle
2847	Jane Doe	Boston

FactSales
SalesKey	CustomerKey	ProductKey	Sales Amount
5001	1523	201	$250
5002	1523	305	$180
5003	1523	401	$320
5004	2847	201	$150

How It Works:

For Customer 1523:

Step 1: RELATEDTABLE( FactSales ) returns all rows where CustomerKey = 1523
        → 3 rows (5001, 5002, 5003)

Step 2: COUNTROWS counts these rows
        → Returns 3

For Customer 2847:

Step 1: RELATEDTABLE( FactSales ) returns all rows where CustomerKey = 2847
        → 1 row (5004)

Step 2: COUNTROWS counts this row
        → Returns 1

Result:

DimCustomer
CustomerKey	Customer Name	City	Number of Orders
1523	John Smith	Seattle	3
2847	Jane Doe	Boston	1

Example 3: Average Sale Amount per Product

Scenario: Calculate the average sale amount for each product.

Data Model:

DimProduct[ProductKey] ←── FactSales[ProductKey]

DAX Formula:

Average Sale Amount =
AVERAGEX(
    RELATEDTABLE( FactSales ),
    FactSales[Sales Amount]
)

Example Calculation:

DimProduct
ProductKey	Product Name
201	Contoso Phone X1

FactSales (for Product 201)
SalesKey	ProductKey	Sales Amount
1001	201	$300
1002	201	$450
1003	201	$600

Step 1: RELATEDTABLE returns 3 sales rows

Step 2: AVERAGEX calculates:
        ($300 + $450 + $600) / 3 = $450

Step 3: Returns $450

Multi-Level Relationships (Chained RELATEDTABLE)

You can use RELATEDTABLE through multiple relationship levels.

Example 4: Total Sales per Category

Data Model:

DimProductCategory ← DimProductSubcategory ← DimProduct ← FactSales
      (One)              (One)                 (One)      (Many)

Scenario: Calculate total sales for each product category.

DAX Formula in DimProductCategory:

Category Total Sales =
SUMX(
    RELATEDTABLE( FactSales ),
    FactSales[Sales Amount]
)

How Multi-Hop Works:

DimProductCategory (Current: CategoryKey = 5)
    ↓
    Find all rows in DimProductSubcategory where CategoryKey = 5
    ↓
    Find all rows in DimProduct with those SubcategoryKeys
    ↓
    Find all rows in FactSales with those ProductKeys
    ↓
    Return: All sales for products in Category 5

Power BI automatically traverses all intermediate relationships!

Example:

DimProductCategory
CategoryKey	Category Name
5	Electronics

↓ Has subcategories

DimProductSubcategory
SubcategoryKey	Subcategory Name	CategoryKey
15	Smartphones	5
16	Laptops	5

↓ Has products

DimProduct
ProductKey	Product Name	SubcategoryKey
201	Phone X1	15
202	Phone X2	15
305	Laptop Pro	16

↓ Has sales

FactSales
SalesKey	ProductKey	Sales Amount
1001	201	$1000
1002	202	$1200
1003	305	$2500

Result for Electronics Category:

Category Total Sales = $1000 + $1200 + $2500 = $4700

Advanced Scenarios

Example 5: Complex Aggregation with Filtering

Scenario: Calculate total sales for high-value transactions only (> $500).

DAX Formula:

High Value Sales =
SUMX(
    FILTER(
        RELATEDTABLE( FactSales ),
        FactSales[Sales Amount] > 500
    ),
    FactSales[Sales Amount]
)

Detailed Breakdown:

High Value Sales =
    -- Step 1: Get all related sales
    SUMX(
        -- Step 2: Filter to only high-value sales
        FILTER(
            RELATEDTABLE( FactSales ),     -- Get all sales for this product
            FactSales[Sales Amount] > 500   -- Keep only sales > $500
        ),
        -- Step 3: Sum the filtered amounts
        FactSales[Sales Amount]
    )

Example Execution:

For Product 201:

Step 1: RELATEDTABLE returns all sales
        Sales: $300, $600, $800, $400

Step 2: FILTER keeps only > $500
        Filtered: $600, $800

Step 3: SUMX adds them up
        Result: $1400

Example 6: Calculate Percentage of Total

Scenario: Calculate what percentage of total company sales each product represents.

DAX Formulas:

// In DimProduct table
Product Sales =
SUMX(
    RELATEDTABLE( FactSales ),
    FactSales[Sales Amount]
)

Product Sales % =
VAR ProductTotal = [Product Sales]
VAR CompanyTotal = CALCULATE( SUM( FactSales[Sales Amount] ), ALL( DimProduct ) )
RETURN
    DIVIDE( ProductTotal, CompanyTotal, 0 )

Example:

DimProduct
ProductKey	Product Name	Product Sales
201	Phone X1	$50,000
305	Laptop Pro	$30,000
401	Tablet Z	$20,000

Total Company Sales: $100,000

Results:

Product	Product Sales	Product Sales %
Phone X1	$50,000	50.0%
Laptop Pro	$30,000	30.0%
Tablet Z	$20,000	20.0%

Example 7: First and Last Purchase Date

Scenario: Find when each customer made their first and last purchase.

DAX Formulas:

// In DimCustomer table
First Purchase Date =
MINX(
    RELATEDTABLE( FactSales ),
    FactSales[Order Date]
)

Last Purchase Date =
MAXX(
    RELATEDTABLE( FactSales ),
    FactSales[Order Date]
)

Days Since Last Purchase =
    TODAY() - [Last Purchase Date]

Example Data:

DimCustomer
CustomerKey	Customer Name
1523	John Smith

FactSales (for Customer 1523)
SalesKey	CustomerKey	Order Date
5001	1523	2024-01-15
5002	1523	2024-03-22
5003	1523	2024-06-10

Results:

Customer	First Purchase	Last Purchase	Days Since Last
John Smith	2024-01-15	2024-06-10	156

Example 8: Product Performance Metrics

Scenario: Create comprehensive product analytics.

DAX Formulas in DimProduct:

Total Units Sold =
SUMX(
    RELATEDTABLE( FactSales ),
    FactSales[Quantity]
)

Total Revenue =
SUMX(
    RELATEDTABLE( FactSales ),
    FactSales[Sales Amount]
)

Total Transactions =
COUNTROWS( RELATEDTABLE( FactSales ) )

Average Transaction Size =
AVERAGEX(
    RELATEDTABLE( FactSales ),
    FactSales[Sales Amount]
)

Largest Single Sale =
MAXX(
    RELATEDTABLE( FactSales ),
    FactSales[Sales Amount]
)

Days on Market =
VAR FirstSale = MINX( RELATEDTABLE( FactSales ), FactSales[Order Date] )
VAR LastSale = MAXX( RELATEDTABLE( FactSales ), FactSales[Order Date] )
RETURN
    DATEDIFF( FirstSale, LastSale, DAY )

Example Dashboard:

Product	Units	Revenue	Transactions	Avg Sale	Largest Sale	Days Active
Phone X1	245	$122,500	87	$1,408	$3,500	365

Example 9: Customer Segmentation

Scenario: Classify customers based on purchase behavior.

DAX Formula:

Customer Segment =
VAR TotalSpent = SUMX( RELATEDTABLE( FactSales ), FactSales[Sales Amount] )
VAR OrderCount = COUNTROWS( RELATEDTABLE( FactSales ) )
VAR Segment =
    SWITCH(
        TRUE(),
        TotalSpent >= 10000 && OrderCount >= 10, "VIP",
        TotalSpent >= 5000 && OrderCount >= 5, "Premium",
        TotalSpent >= 1000, "Regular",
        "Occasional"
    )
RETURN
    Segment

Step-by-Step Logic:

For Customer 1523:

Step 1: RELATEDTABLE gets all sales (15 orders, $12,500 total)

Step 2: Calculate totals
        TotalSpent = $12,500
        OrderCount = 15

Step 3: Evaluate conditions
        $12,500 >= $10,000 AND 15 >= 10 → TRUE
        → Returns "VIP"

Example 10: Time-Based Analysis

Scenario: Calculate year-over-year growth per product.

DAX Formula:

Sales This Year =
VAR CurrentYear = YEAR( TODAY() )
RETURN
    SUMX(
        FILTER(
            RELATEDTABLE( FactSales ),
            YEAR( FactSales[Order Date] ) = CurrentYear
        ),
        FactSales[Sales Amount]
    )

Sales Last Year =
VAR LastYear = YEAR( TODAY() ) - 1
RETURN
    SUMX(
        FILTER(
            RELATEDTABLE( FactSales ),
            YEAR( FactSales[Order Date] ) = LastYear
        ),
        FactSales[Sales Amount]
    )

YoY Growth % =
VAR ThisYear = [Sales This Year]
VAR LastYear = [Sales Last Year]
RETURN
    DIVIDE(
        ThisYear - LastYear,
        LastYear,
        0
    )

Example Result:

Product	2023 Sales	2024 Sales	YoY Growth %
Phone X1	$50,000	$65,000	30.0%
Laptop Pro	$80,000	$72,000	-10.0%

RELATEDTABLE with Different Iterator Functions

Using SUMX (Most Common)

Total Sales =
SUMX(
    RELATEDTABLE( FactSales ),
    FactSales[Sales Amount]
)

Using COUNTROWS (Count Records)

Transaction Count =
COUNTROWS( RELATEDTABLE( FactSales ) )

Using AVERAGEX (Calculate Average)

Average Order Value =
AVERAGEX(
    RELATEDTABLE( FactSales ),
    FactSales[Sales Amount]
)

Using MAXX (Find Maximum)

Largest Order =
MAXX(
    RELATEDTABLE( FactSales ),
    FactSales[Sales Amount]
)

Using MINX (Find Minimum)

Smallest Order =
MINX(
    RELATEDTABLE( FactSales ),
    FactSales[Sales Amount]
)

Using FILTER (Conditional Aggregation)

Large Orders =
COUNTROWS(
    FILTER(
        RELATEDTABLE( FactSales ),
        FactSales[Sales Amount] > 1000
    )
)

Using CONCATENATEX (Create Lists)

Product List =
CONCATENATEX(
    RELATEDTABLE( FactSales ),
    FactSales[Product Name],
    ", ",
    FactSales[Order Date],
    ASC
)

Handling Empty Results

Example 11: Safe RELATEDTABLE with No Matches

Scenario: Handle products with no sales gracefully.

DAX Formula:

Total Sales Safe =
VAR RelatedSales = RELATEDTABLE( FactSales )
VAR HasSales = NOT ISEMPTY( RelatedSales )
RETURN
    IF(
        HasSales,
        SUMX( RelatedSales, FactSales[Sales Amount] ),
        0
    )

Or simpler:

Total Sales =
SUMX(
    RELATEDTABLE( FactSales ),
    FactSales[Sales Amount]
) + 0

The + 0 ensures BLANK becomes 0.

Example:

Product	Total Sales Safe
Phone X1 (has sales)	$50,000
New Product (no sales)	$0

Common Patterns and Use Cases

Pattern 1: Customer Lifetime Value

Customer Lifetime Value =
SUMX(
    RELATEDTABLE( FactSales ),
    FactSales[Sales Amount] - FactSales[Cost Amount]
)

Pattern 2: Product Velocity

Sales Velocity (Units/Day) =
VAR TotalUnits = SUMX( RELATEDTABLE( FactSales ), FactSales[Quantity] )
VAR FirstSale = MINX( RELATEDTABLE( FactSales ), FactSales[Order Date] )
VAR LastSale = MAXX( RELATEDTABLE( FactSales ), FactSales[Order Date] )
VAR DaysActive = DATEDIFF( FirstSale, LastSale, DAY ) + 1
RETURN
    DIVIDE( TotalUnits, DaysActive, 0 )

Pattern 3: Repeat Customer Flag

Is Repeat Customer =
VAR OrderCount = COUNTROWS( RELATEDTABLE( FactSales ) )
RETURN
    IF( OrderCount > 1, "Yes", "No" )

Pattern 4: Top Product by Customer

Top Product =
VAR ProductSales =
    ADDCOLUMNS(
        RELATEDTABLE( FactSales ),
        "Product", RELATED( DimProduct[Product Name] ),
        "Total", FactSales[Sales Amount]
    )
VAR TopProduct =
    TOPN(
        1,
        SUMMARIZE( ProductSales, [Product], "Sales", SUM( [Total] ) ),
        [Sales],
        DESC
    )
RETURN
    MAXX( TopProduct, [Product] )

Pattern 5: Active vs Inactive Status

Customer Status =
VAR LastPurchase = MAXX( RELATEDTABLE( FactSales ), FactSales[Order Date] )
VAR DaysSincePurchase = DATEDIFF( LastPurchase, TODAY(), DAY )
RETURN
    SWITCH(
        TRUE(),
        DaysSincePurchase <= 90, "Active",
        DaysSincePurchase <= 180, "At Risk",
        "Inactive"
    )

Performance Considerations

Tip 1: Use RELATEDTABLE Efficiently

Less Efficient:

// Calling RELATEDTABLE multiple times
Metric 1 = SUMX( RELATEDTABLE( FactSales ), FactSales[Amount] )
Metric 2 = COUNTROWS( RELATEDTABLE( FactSales ) )
Metric 3 = AVERAGEX( RELATEDTABLE( FactSales ), FactSales[Quantity] )

More Efficient:

// Store RELATEDTABLE in a variable
Combined Metrics =
VAR RelatedSales = RELATEDTABLE( FactSales )
VAR TotalAmount = SUMX( RelatedSales, FactSales[Amount] )
VAR TotalCount = COUNTROWS( RelatedSales )
VAR AvgQty = AVERAGEX( RelatedSales, FactSales[Quantity] )
RETURN
    TotalAmount & " | " & TotalCount & " | " & AvgQty

Tip 2: Filter Early

Less Efficient:

// Filter after getting all rows
Current Year Sales =
VAR AllSales = RELATEDTABLE( FactSales )
RETURN
    SUMX(
        FILTER( AllSales, YEAR( FactSales[Order Date] ) = 2024 ),
        FactSales[Sales Amount]
    )

More Efficient:

// Use CALCULATE to filter before RELATEDTABLE
Current Year Sales =
CALCULATE(
    SUMX( RELATEDTABLE( FactSales ), FactSales[Sales Amount] ),
    YEAR( FactSales[Order Date] ) = 2024
)

Tip 3: Avoid in Calculated Columns When Possible

❌ SLOWER: Calculated column in DimProduct
Product Total = SUMX( RELATEDTABLE( FactSales ), FactSales[Amount] )

✅ FASTER: Measure
Product Total = SUMX( RELATEDTABLE( FactSales ), FactSales[Amount] )

Why: Calculated columns are stored and calculated during refresh. Measures calculate on-demand.

Common Errors and Troubleshooting

Error 1: "Relationship is required"

Error Message:

The column 'FactSales' cannot be found in the current context.

Cause: No relationship exists between tables.

Solution:

Check Model View - Verify relationship line exists
Check relationship direction - Should be from dimension to fact
Verify cardinality - Should be One-to-Many (1:*)

Error 2: RELATEDTABLE Returns Empty

Problem: Formula returns 0 or BLANK when data should exist.

Diagnosis:

// Check if relationship returns rows
Row Count Check =
VAR RelatedRows = RELATEDTABLE( FactSales )
VAR RowCount = COUNTROWS( RelatedRows )
RETURN
    "Found " & RowCount & " related rows"

Possible Causes:

Relationship is inactive (dashed line)
Filter context is removing all rows
Foreign keys in fact table don't match dimension

Error 3: Circular Dependency

Problem:

// In DimProduct
Product Sales = SUMX( RELATEDTABLE( FactSales ), FactSales[Amount] )

// In FactSales
Product Total = RELATED( DimProduct[Product Sales] )

// ERROR: Circular dependency!

Solution: Don't reference aggregated columns back in fact tables.

RELATEDTABLE vs Other Functions

RELATEDTABLE vs CALCULATETABLE

Function	Purpose	Context
RELATEDTABLE	Get related rows via relationship	Follows relationships
CALCULATETABLE	Apply filters to get rows	Can work without relationships

Example:

// Using RELATEDTABLE (needs relationship)
Product Sales = SUMX( RELATEDTABLE( FactSales ), FactSales[Amount] )

// Using CALCULATETABLE (can work without relationship)
Product Sales =
SUMX(
    CALCULATETABLE(
        FactSales,
        FactSales[ProductKey] = DimProduct[ProductKey]
    ),
    FactSales[Amount]
)

When to use RELATEDTABLE: ✅

Relationship exists
Following natural data model paths
Better performance

When to use CALCULATETABLE: ✅

Need complex filtering
Working with many-to-many scenarios
No relationship exists

RELATEDTABLE vs ALL(FactTable)

Function	Returns	Use Case
RELATEDTABLE	Related rows only	Get connected data
ALL(FactTable)	All rows (ignores filters)	Calculate grand totals

Example:

// Related sales only
Product Sales = SUMX( RELATEDTABLE( FactSales ), FactSales[Amount] )

// All sales (for percentage calculation)
Company Sales = SUMX( ALL( FactSales ), FactSales[Amount] )

Best Practices Summary

✅ DO:

Use RELATEDTABLE in dimension tables (One side):

Total Sales = SUMX( RELATEDTABLE( FactSales ), FactSales[Amount] )

Store RELATEDTABLE in variables for multiple operations:

VAR RelatedSales = RELATEDTABLE( FactSales )
VAR Total = SUMX( RelatedSales, ... )
VAR Count = COUNTROWS( RelatedSales )

Always use with iterator functions (SUMX, COUNTROWS, etc.):

✅ SUMX( RELATEDTABLE( FactSales ), ... )
❌ RELATEDTABLE( FactSales )  // Just returns table

Check for empty results when appropriate:

VAR Related = RELATEDTABLE( FactSales )
RETURN IF( ISEMPTY( Related ), 0, SUMX( Related, ... ) )

Verify relationships in Model View before using

❌ DON'T:

Don't use RELATEDTABLE in fact tables (Many side):

❌ WRONG: In FactSales
Product Name = RELATEDTABLE( DimProduct[Product Name] )

✅ USE RELATED INSTEAD:
Product Name = RELATED( DimProduct[Product Name] )

Don't use without an iterator:

❌ WRONG:
Product Total = RELATEDTABLE( FactSales )

✅ CORRECT:
Product Total = SUMX( RELATEDTABLE( FactSales ), FactSales[Amount] )

Don't call RELATEDTABLE repeatedly:

❌ INEFFICIENT:
Measure =
    SUMX( RELATEDTABLE( FactSales ), ... ) +
    COUNTROWS( RELATEDTABLE( FactSales ) )

✅ EFFICIENT:
VAR Related = RELATEDTABLE( FactSales )

Don't ignore relationship cardinality:

Must be One-to-Many (1:*)
Dimension (One) → Fact (Many)

Don't use in calculated columns unless necessary:

Prefer measures for better performance
Calculated columns increase model size

Quick Reference Templates

Template 1: Sum Aggregation

// In DIMENSION table
Total [Metric] =
SUMX(
    RELATEDTABLE( FactTable ),
    FactTable[Amount Column]
)

Template 2: Count

// In DIMENSION table
Count of [Items] =
COUNTROWS( RELATEDTABLE( FactTable ) )

Template 3: Average

// In DIMENSION table
Average [Metric] =
AVERAGEX(
    RELATEDTABLE( FactTable ),
    FactTable[Amount Column]
)

Template 4: With Filter

// In DIMENSION table
Filtered [Metric] =
SUMX(
    FILTER(
        RELATEDTABLE( FactTable ),
        FactTable[Condition Column] = "Value"
    ),
    FactTable[Amount Column]
)

Template 5: Date Range

// In DIMENSION table
[Metric] Last 30 Days =
SUMX(
    FILTER(
        RELATEDTABLE( FactTable ),
        FactTable[Date] >= TODAY() - 30
    ),
    FactTable[Amount Column]
)

Template 6: Multiple Calculations

// In DIMENSION table
Combined Metric =
VAR Related = RELATEDTABLE( FactTable )
VAR Total = SUMX( Related, FactTable[Amount] )
VAR Count = COUNTROWS( Related )
VAR Average = AVERAGEX( Related, FactTable[Amount] )
RETURN
    Total & " | " & Count & " | " & FORMAT( Average, "$#,0.00" )

Summary

The RELATEDTABLE function is essential for aggregating fact data at the dimension level:

Follows relationships from One → Many side automatically
Works in dimension tables (One side of relationship)
Returns a table of all related rows
Must be used with iterator functions (SUMX, COUNTROWS, etc.)
Enables powerful aggregations at dimension grain

Key Takeaway: RELATEDTABLE brings the many rows from your fact tables into dimension-level calculations, enabling you to create comprehensive analytics, KPIs, and metrics that answer questions like "What's the total for this product?" or "How many times did this customer buy?"

Remember:

In Dimension (One) → Use RELATEDTABLE → Get Many rows → Aggregate them
In Fact (Many) → Use RELATED → Get One value → Use directly

Master RELATEDTABLE alongside RELATED, and you'll have complete control over navigating relationships in your Power BI data model! 🎯