Microsoft Power BI • Connecting to Data

Using Shared Datasets — Use a shared dataset / semantic model to build a report (intro)

Build multiple reports from a single, governed semantic model to ensure consistency and reduce redundancy across your organization.

Microsoft Power BI emblem with a dashboard, stacked chart, and database.
Inside this lesson 10 sections 5 questions 4 figures

SECTION 1

Historical Context & Motivation

In the early days of business intelligence, every report author typically built their own data connections, transformations, and measure definitions from scratch. This approach created a proliferation of conflicting metric definitions—one team's 'revenue' figure might differ from another's because of subtle differences in filters, exchange-rate logic, or date-boundary handling. The resulting inconsistencies eroded trust in BI platforms and forced organizations to invest heavily in manual reconciliation. Microsoft Power BI addressed this challenge by introducing the concept of a shared dataset (now formally called a semantic model), enabling multiple reports to connect to one authoritative, curated data layer. This paradigm shift mirrors the evolution from ad-hoc SQL scripts to centralized data warehouses in traditional analytics—only now it operates at the self-service BI layer, empowering report authors without sacrificing governance.

2015 • Power BI Desktop Launches

Microsoft releases Power BI Desktop, bundling data modeling, transformations, and visualization into a single .pbix file. Each report carries its own embedded dataset, making sharing and reuse difficult.

2018 • Shared Datasets in Power BI Service

Power BI Service introduces the ability to publish a dataset separately and let other report authors connect to it via a 'live connection.' This decouples the data model from the report layer for the first time.

2020 • Dataset Endorsement & Certification

Microsoft adds Promoted and Certified endorsement labels, giving data stewards a governance mechanism to signal which datasets are trusted and recommended for organization-wide use.

2023 • Rebranding to Semantic Models

Microsoft rebrands 'datasets' as 'semantic models' to better reflect their role as rich, business-logic-laden analytical layers rather than simple data containers. The underlying technology (Analysis Services tabular model) remains the same.

2024 • Microsoft Fabric Integration

Semantic models become first-class citizens in Microsoft Fabric, with Direct Lake mode enabling near-real-time access to lakehouse data while preserving the shared-model paradigm.

The fundamental question that shared datasets answer is deceptively simple: how do we ensure that every report in the organization computes 'total revenue,' 'active users,' or 'churn rate' the same way? Without a shared semantic layer, each report author re-implements these definitions independently, and subtle discrepancies inevitably emerge. By centralizing the data model, relationships, and DAX measures in a single published semantic model, Power BI transforms the problem from one of distributed consistency—notoriously difficult in computer science—into a straightforward architectural pattern of a single source of truth.

SECTION 2

Core Principles & Definitions

Understanding shared datasets in Power BI requires grasping several interrelated concepts that together form the architecture of a governed, scalable BI environment. At the center is the semantic model—the analytical engine that stores tables, relationships, hierarchies, and business logic. Around it, connection modes, workspace permissions, and endorsement mechanisms control who can consume the model and how.

1

Semantic Model

A published Analysis Services tabular model containing tables, relationships, calculated columns, and DAX measures. It is the single source of truth for metric definitions across all connected reports.
2

Live Connection

A report-to-model binding where the report contains no local data. All queries are sent to the remote semantic model at runtime, ensuring the report always reflects the latest data and business logic.
3

Build Permission

A workspace-level or item-level permission that grants a user the ability to create new reports against a shared semantic model. Without Build permission, users can view existing reports but cannot author new ones.
4

Endorsement (Promoted / Certified)

Governance labels applied by workspace owners (Promoted) or designated data stewards (Certified) indicating a model's quality and trustworthiness. Certified models appear prominently in the data hub for discoverability.
5

Thin Reports

Reports that contain only visualizations, page layouts, and formatting—no embedded data model. They are lightweight, quick to publish, and derive all analytical power from the underlying shared semantic model.
✦

KEY TAKEAWAY

Think of a shared semantic model like a well-documented REST API. The API contract (schema, endpoints, response format) is defined once and maintained by a dedicated team, while multiple front-end applications consume it independently. If the API team fixes a bug in the pricing calculation, every front-end app instantly benefits without redeployment. Similarly, when a data steward corrects a DAX measure in a shared semantic model, every connected report reflects the fix immediately—no report-level changes required.

SECTION 3

Visual Explanation — Architecture Overview

The following diagram illustrates the shared dataset architecture in Power BI. At the center, a single semantic model connects upstream to data sources and downstream to multiple thin reports. Notice how the model owner publishes and governs the semantic model in a workspace, while report authors in separate workspaces create reports that reference it via live connections.

Shared Semantic Model ArchitectureSQL DatabaseExcel / CSVREST APIData SourcesSemantic ModelTables & RelationshipsDAX MeasuresHierarchiesRow-Level Security✓ CertifiedImport /DirectQuerySales Report(thin report)Finance Report(thin report)Exec Dashboard(thin report)Connected ReportsLiveConnectionGovernance Layer• Build Permission control• Endorsement (Promoted / Certified)• Row-Level Security (RLS)
The architecture diagram shows three data sources on the left feeding into a single semantic model (center) via Import or DirectQuery. Three thin reports (right) connect to that model via live connections. The governance layer beneath the model indicates the permission and endorsement mechanisms that secure access.

The critical insight from this architecture is the separation of concerns between data modeling and report authoring. The model owner—typically a data engineer or analytics engineer—maintains the semantic model's schema, relationships, and DAX measures. Report authors, who may be business analysts or domain experts, focus exclusively on building visualizations and crafting narratives. This division of labor is analogous to the front-end/back-end split in web development: the API team guarantees correct data, and the UI team consumes it to build user experiences. Neither team needs to duplicate the other's work.

SECTION 4

How It Works — Connection Mechanics

When you build a report on top of a shared semantic model, the underlying protocol is XMLA (XML for Analysis), the same protocol that Analysis Services has used for decades. Power BI Desktop and the Power BI Service both issue DAX queries against the remote Analysis Services engine hosting the semantic model. The report file (.pbix or .rdl) itself stores only the visual definitions, page layouts, filters, and the connection string pointing to the published model—it contains zero rows of data.

Step-by-Step: Connecting to a Shared Semantic Model

  1. Discover the model. In Power BI Desktop, navigate to Home → Get Data → Power BI semantic models (or 'Power BI datasets' in older versions). Alternatively, in the Power BI Service, click '+ New report' from the semantic model's context menu.
  2. Authenticate and authorize. Power BI validates your Azure AD (Entra ID) credentials and checks whether you hold Build permission on the target model. If you lack this permission, the model will not appear in the picker.
  3. Establish a live connection. Power BI creates an XMLA endpoint connection to the hosted semantic model. The local .pbix file records this connection string and stores no data locally.
  4. Author visuals. You drag fields and measures from the Fields pane (populated by the remote model) onto the canvas. Each visual generates a DAX query sent to the model at render time.
  5. Publish the thin report. Publish the .pbix to any workspace. The report retains its live connection to the original semantic model, even if it lives in a different workspace.
⚠

Important: Read-Only Model Access

When connected via live connection, you cannot modify the semantic model's tables, relationships, or measures from the report. You can, however, add report-level measures—DAX expressions scoped only to your report—without altering the shared model. This preserves the integrity of the single source of truth while giving report authors flexibility.

Under the hood, Power BI's query engine translates each visual into a DAX query, serializes it as an XMLA request, and sends it to the Analysis Services instance hosting the semantic model. The engine evaluates the query against the in-memory columnar storage (VertiPaq) or proxies it to the underlying source (DirectQuery), then returns the result set. This mechanism is transparent to the report author—visuals simply render the returned data. The performance characteristics, however, differ based on whether the semantic model uses Import mode (data cached in VertiPaq, fast but periodic refresh) or DirectQuery mode (queries forwarded to the source in real time, slower but always current).

SECTION 5

Detailed Workflow & Data Hub Discovery

The Power BI data hub (sometimes called the OneLake data hub) is the primary discovery interface for shared semantic models. It aggregates all semantic models, dataflows, and other data items the user has access to, surfacing endorsement status, owner information, refresh schedules, and usage metrics. Understanding how to navigate this hub efficiently is essential for report authors who need to identify the right model before building a report.

Report Author Workflow: From Discovery to PublishSTEP 1Open Data HubBrowse / Searchsemantic modelsSTEP 2Evaluate ModelCheck endorsement,owner, refresh freq.STEP 3Create ReportClick "Create report"→ live connectionSTEP 4Build & PublishAuthor visuals,publish thin reportKey Decisions at Each StepDiscovery• Filter by workspace• Filter by endorsement• Search by keyword• View usage metricsTip: Prefer Certifiedmodels when availableEvaluation• Review table schema• Inspect DAX measures• Check refresh schedule• Verify RLS rulesTip: Contact the ownerfor documentationAuthoring• Drag fields to canvas• Use existing measures• Add report measures• Apply report filtersTip: Reuse existingmeasures when possiblePublishing• Publish to workspace• Report ≠ model workspace• Set report permissions• Pin to dashboardsTip: Use deploymentpipelines for staging
The four-step workflow for a report author: discover models in the data hub, evaluate model quality and endorsement, create a live-connected report, and publish the thin report. The detail cards below each step outline key considerations.

Discovering the right semantic model is a non-trivial step in enterprise environments where dozens or hundreds of models may exist. The data hub's filtering capabilities—by workspace, endorsement status, and keyword—help narrow the search. Pay particular attention to the Certified badge: it signifies that a Power BI admin or designated data steward has verified the model's data quality, measure correctness, and documentation. Models labeled Promoted have been recommended by their workspace owners but have not undergone formal certification review. In a well-governed organization, report authors should default to Certified models unless a specific use case requires a different dataset.

SECTION 6

Worked Example — Building a Report on a Shared Model

Suppose your organization's data team has published a Certified semantic model called Enterprise Sales Model in the 'Analytics Hub' workspace. It contains tables for FactSales, DimProduct, DimDate, and DimCustomer, along with DAX measures such as [Total Revenue], [Gross Margin %], and [YoY Growth]. You need to build a quarterly sales performance report for the executive team.

Creating a Quarterly Sales Report on a Shared Semantic Model

  1. 1

    Step 1 — Open Power BI Desktop and Connect

    Launch Power BI Desktop. From the ribbon, click Home → Get Data → Power BI semantic models. The data hub dialog opens, listing all semantic models you have Build permission on. Use the search bar to type 'Enterprise Sales.' Locate the model with the Certified badge and click Connect.
    A live connection to Enterprise Sales Model is established. The Fields pane populates with all tables and measures.
  2. 2

    Step 2 — Verify the Fields Pane

    Expand each table in the Fields pane to confirm you can see the expected columns. Notice that the Data and Model views are grayed out—this is expected because the model is read-only. You are operating in Report view only. Verify that [Total Revenue] and [Gross Margin %] appear as measures (denoted by a calculator icon).
    Fields pane shows all expected tables and measures; Data and Model views are disabled.
  3. 3

    Step 3 — Build a Clustered Bar Chart

    Insert a Clustered Bar Chart visual. Drag DimDate[Quarter] to the Y-axis and [Total Revenue] to the X-axis. Add DimProduct[Category] to the Legend well to segment revenue by product category. The visual immediately queries the remote semantic model and renders the results.
    A clustered bar chart displays quarterly revenue segmented by product category.
  4. 4

    Step 4 — Add a Report-Level Measure

    Suppose you need a custom metric not in the shared model: 'Revenue per Customer.' Right-click the FactSales table and select 'New measure.' Enter the DAX: Revenue per Customer = DIVIDE([Total Revenue], DISTINCTCOUNT(FactSales[CustomerKey])). This measure exists only in your report file and does not modify the shared model.
    A report-level measure [Revenue per Customer] is now available for visuals in this report only.
  5. 5

    Step 5 — Publish the Thin Report

    Click Home → Publish and select the 'Executive Reports' workspace. Power BI uploads only the report definition (visuals, layout, filters, report-level measures). The .pbix file is small because it contains no data—the live connection to Enterprise Sales Model in the 'Analytics Hub' workspace is preserved. Any user with access to both the report and the underlying model can now view the dashboard.
    Published thin report in 'Executive Reports' workspace, live-connected to the Certified semantic model in 'Analytics Hub.'

SECTION 7

Strengths & Limitations of Shared Semantic Models

Like any architectural pattern, shared semantic models introduce trade-offs. Understanding these trade-offs is crucial for deciding when to use a shared model versus embedding a local dataset in your report.

DimensionStrengthsLimitations
ConsistencySingle source of truth for metrics. All reports compute measures identically.If the shared model contains an error, it propagates to all connected reports simultaneously.
GovernanceEndorsement, Build permission, and RLS provide layered access control and quality signals.Requires organizational discipline to maintain endorsement labels and documentation.
PerformanceModel is loaded once in memory; multiple reports reuse the same engine instance, reducing total resource consumption.Heavy concurrent usage from many reports can cause resource contention on shared capacity. Premium or Fabric capacity may be required.
FlexibilityReport authors can add report-level measures without modifying the core model.Cannot add tables, relationships, or calculated columns at the report level. Schema changes require the model owner.
MaintainabilityFix a measure once; all reports inherit the fix. Dramatically reduces maintenance burden.Breaking schema changes (e.g., renaming a column) can break downstream reports if not coordinated.

Comparison of strengths and limitations when using shared semantic models

✦

KEY TAKEAWAY

Shared semantic models follow the same principle as a well-designed microservice API with a published contract. When you version the contract carefully and communicate breaking changes, downstream consumers benefit enormously from code (or in this case, logic) reuse. When you don't, a single breaking change can cascade into widespread failures. In Power BI, tools like deployment pipelines and impact analysis help manage this contract, but organizational process is equally important.

SECTION 8

Connection to Advanced Concepts

Shared semantic models serve as the foundational building block for several advanced Power BI and Microsoft Fabric features. As you progress, you will encounter patterns that extend the basic live-connection paradigm into more sophisticated architectures. Understanding how this introductory concept maps to those advanced features will help you plan scalable BI solutions.

Introductory ConceptAdvanced ExtensionKey Difference
Live connection to a single semantic modelComposite modelsAllows adding local Import tables alongside the remote model, enabling mashups without duplicating the core model.
Report-level measuresCalculation groupsCentrally defined DAX templates (e.g., YTD, MTD, PY) that apply to any measure, managed at the model level via Tabular Editor.
Endorsement (Promoted / Certified)Purview integrationMicrosoft Purview extends governance with data lineage visualization, sensitivity labels, and cross-platform cataloging.
Import / DirectQuery modesDirect Lake modeIn Microsoft Fabric, Direct Lake reads Parquet files directly from OneLake—no import needed, yet queries run at near-Import speeds.
Manual publish from DesktopDeployment pipelines (CI/CD)Manages Dev → Test → Prod stages with automated rules, parameter swaps, and approval gates for both models and reports.

Mapping introductory shared-dataset concepts to advanced Power BI features

The most important advanced extension to be aware of is composite models. While a pure live connection restricts you to the remote model's schema, composite models let you add local Import or DirectQuery tables that join to the shared model's tables via relationships you define. This is analogous to extending a base class in object-oriented programming: you inherit the core functionality (shared measures, relationships) while adding domain-specific data (a local spreadsheet, a departmental database) at the report level. However, composite models introduce additional complexity around data staleness and security boundaries, so they should be used judiciously.

SECTION 9

Practice Problems

Question 1: CONCEPTUAL

Explain the difference between a 'semantic model' and a 'report' in Power BI. Why does Microsoft encourage separating these two artifacts, and what problem does this separation solve for organizations with multiple BI teams?
Show answer
A semantic model is the data layer—it contains tables, relationships, calculated columns, DAX measures, and potentially row-level security rules. A report is the presentation layer—it holds visual definitions, page layouts, filters, and formatting. Microsoft encourages separating them because it creates a single source of truth for metric definitions. Without this separation, each report author independently defines measures like 'Total Revenue,' leading to inconsistent numbers across the organization. By centralizing the model, changes to business logic propagate automatically to all connected reports, reducing maintenance overhead and eliminating metric discrepancies.

Question 2: BASIC CALCULATION

An organization has 12 reports, each with its own embedded dataset containing identical tables and measures. Each dataset is approximately 500 MB in memory. If the organization migrates to a shared semantic model architecture, estimate: (a) the total memory savings in GB, and (b) how many fewer data refresh schedules need to be maintained, assuming each embedded dataset had its own refresh schedule.
Show answer
(a) With 12 separate datasets: 12 × 500 MB = 6,000 MB = 6 GB. With one shared model: 500 MB = 0.5 GB. Memory savings: 6 − 0.5 = 5.5 GB. (b) Previously, 12 separate refresh schedules were needed. Now, only 1 refresh schedule is required for the shared model. That eliminates 11 refresh schedules. Note that actual savings may vary due to caching behavior and concurrent query loads, but the order-of-magnitude reduction is representative of real-world benefits.

Question 3: INTERMEDIATE

You are a report author connected to a shared semantic model via live connection. You need to create a measure called [Avg Order Value] defined as DIVIDE([Total Revenue], [Order Count]), but this measure does not exist in the shared model. Describe how you would add this measure, explain its scope, and discuss the implications if the model owner later adds a measure with the same name to the shared model.
Show answer
You would add a report-level measure by right-clicking any table in the Fields pane and selecting 'New measure,' then entering the DAX formula. This measure is scoped entirely to your report—it is stored in the .pbix file and does not appear in other reports connected to the same model. If the model owner later adds a measure with the same name ([Avg Order Value]) to the shared model, a naming conflict arises. Power BI will typically use the model-level measure for visuals, and the report-level measure may be shadowed or produce an error. The recommended practice is to prefix report-level measures (e.g., [RPT_Avg Order Value]) to avoid collisions, and to proactively request important measures be added to the shared model.

Question 4: APPLIED

Your company has three departments—Sales, Marketing, and Finance—each building Power BI reports. Currently, Sales and Marketing each maintain their own dataset with slightly different definitions of 'Active Customer.' The CFO has noticed conflicting numbers in board presentations. Design a solution using shared semantic models: specify who owns the model, where it is published, what endorsement level it should have, and how Build permissions should be assigned. Justify each decision.
Show answer
The analytics engineering team (or a cross-functional data governance team) should own the semantic model, as they can objectively define metrics without departmental bias. The model should be published to a dedicated workspace (e.g., 'Certified Data Models') that is managed by this team. The model should receive 'Certified' endorsement after the data governance committee reviews and approves the 'Active Customer' definition. Build permission should be granted to specific security groups: SalesAnalysts, MarketingAnalysts, and FinanceAnalysts—granting Build permission at the model level rather than workspace level to follow the principle of least privilege. Each department publishes their reports to their own workspaces, but all reports share the single certified model. This ensures the CFO sees one consistent 'Active Customer' count across all board presentations.

Question 5: CRITICAL THINKING

A shared semantic model uses Import mode with a scheduled refresh every 6 hours. A report author connected via live connection notices that the data in their report is stale—it does not reflect a batch of orders loaded into the source SQL database 30 minutes ago. The author argues that 'live connection' should mean 'real-time data.' Critique this reasoning. Then propose two alternative architectures that would reduce data latency while preserving the shared-model governance benefits.
Show answer
The author's reasoning conflates two different meanings of 'live.' A live connection means the report does not cache data locally—every visual query is sent to the remote semantic model at render time. However, the semantic model itself uses Import mode, meaning its data is a snapshot refreshed on a schedule. 'Live' refers to the connection, not the data freshness. Two architectures to reduce latency: (1) Switch the semantic model to DirectQuery mode, where every query is forwarded to the source SQL database in real time. This eliminates staleness but may degrade performance for complex DAX queries. (2) Adopt a hybrid approach using Direct Lake mode in Microsoft Fabric, where the semantic model reads Parquet files from OneLake that are updated via near-real-time streaming pipelines (e.g., Spark Structured Streaming). This provides sub-minute latency with near-Import query performance. Both architectures preserve the shared-model governance since the semantic model remains the central, certified artifact that all reports connect to.

SUMMARY

Summary

Summary

A shared semantic model in Power BI is a centrally published data layer containing tables, relationships, and DAX measures that serves as a single source of truth for metric definitions across an organization. Report authors connect to it via live connections, producing lightweight thin reports that contain only visuals and layouts—no embedded data. This separation of concerns mirrors established software engineering patterns: the semantic model is the API, and reports are the consumers.

Governance is enforced through Build permissions (controlling who can author reports against the model), endorsement labels (Promoted and Certified, signaling data quality), and row-level security (restricting data visibility per user). Report authors retain flexibility through report-level measures and can extend the pattern further with composite models. This architecture reduces redundancy, ensures consistency, and scales gracefully as the number of reports grows.

Varsity Tutors • Microsoft Power BI • Using Shared Datasets — Use a shared dataset / semantic model to build a report (intro)