Skip to content

Power BI Architecture: Governed Models, RLS, and Safe Releases

A medium-scale Azure blueprint for trusted Power BI semantic models, dynamic row-level security, staged deployment, and operational visibility.

Ekanatha Reddy Urivakili18 min3,408 words

1. Context and scale

Power BI architecture succeeds or fails at the semantic layer. A report can render quickly and still be wrong because measures have inconsistent definitions, row-level security (RLS) is bypassed by an overprivileged workspace role, or a release changes the production model without an accountable review.

This blueprint targets an internal analytics platform for a mid-sized organization. Azure provides the data landing zone and warehouse; Power BI provides the semantic model, reports, and user experience. The design uses one primary semantic model for shared business measures, with a small number of subject-area models where ownership or security boundaries require separation.

Assumptions — capacity and team sizing, not product limits:

DimensionPlanning assumption
Users30,000 daily users; 100,000 provisioned users across the organization
Requests15 interactive report queries/s sustained; 60/s short peak
ConcurrencyUp to 500 active report viewers during a major business event
Data volume1 TB compressed analytical data; 20 GB daily change; five years of detail
RefreshIncremental daily refresh, plus targeted intraday refresh for selected subject areas
TeamOne BI/data team of 5–7 people and a platform team of 2–3; shared security support
BudgetAssumption-based monthly platform envelope of $12,000–$25,000, excluding labor and end-user licenses

These figures size the initial architecture, not a guarantee of service capacity. Capacity selection must be validated with representative models, refreshes, concurrency, and the organization’s licensing terms.

The design assumes internal users authenticate with Microsoft Entra ID and access reports through the Power BI service. It is not a public, anonymous, or customer-embedded analytics design. Build for predictable use and governed reuse rather than creating a separate workspace, model, and metric definition for every report.

2. Requirements

Functional requirements

RequirementDesign response
Consistent measuresPublish certified semantic models with centrally owned measures and descriptions.
Different access by region or business unitApply dynamic RLS using a governed user-to-scope mapping table and Entra identities.
Self-service reportingAllow approved authors to build thin reports against certified models, without changing core measures.
Reliable data updatesLand source data in a lake, transform it into a star schema, and refresh models incrementally where supported.
Controlled promotionPromote the same artifact through development, test, and production stages with explicit approvals.
Auditable ownershipAssign data owners, model owners, workspace owners, and release approvers.

Non-functional requirements

RequirementInitial target or constraint
Availability99.9% monthly availability for the reporting experience, subject to the selected Power BI capacity and upstream dependencies.
FreshnessDaily data complete by 07:00 local business time; selected operational subject areas target hourly updates.
Query performance95% of common report interactions complete within 5 seconds under agreed test conditions.
SecurityEntra authentication, least-privilege workspace roles, RLS testing, encrypted connections, and managed secrets.
RecoverabilityRebuildable warehouse and models; documented recovery of deployment configuration and source artifacts.
Change safetyAutomated validation, staging verification, approval before production promotion, and rollback procedure.
Cost controlCapacity and refresh monitored against usage; isolate expensive models before increasing capacity.

These targets are service objectives for the whole reporting path, not promises made by an individual Power BI feature. The organization should define business hours, exclusions, and the measurement point before treating an SLO as contractual.

3. High-level design

Azure Data Factory orchestrates source ingestion into Azure Data Lake Storage Gen2. A transformation job builds curated dimensional tables in Azure SQL Database. Power BI semantic models use Import mode for the main analytical workload: it gives predictable interactive performance and avoids sending every visual interaction to the warehouse. Incremental refresh limits the work required to keep large facts current.

Entra ID authenticates users. Power BI applies model permissions and dynamic RLS when a user queries the semantic model. Workspace roles are reserved for authors and operators; ordinary consumers receive app access and model read permission, not elevated workspace roles.

flowchart LR
    src["Operational sources"] --> adf["Azure Data Factory"]
    adf --> lake["ADLS Gen2 raw and curated"]
    lake --> sql["Azure SQL Database warehouse"]
    sql --> model["Power BI semantic model"]
    model --> reports["Power BI reports and app"]
    users["Entra ID users and groups"] --> reports
    users --> model
    adf --> monitor["Azure Monitor and Log Analytics"]
    model --> monitor
    reports --> monitor
    dev["Azure DevOps repository and pipeline"] --> deploy["Power BI deployment pipeline"]
    deploy --> model

The path from source data through a governed model to report consumers, with identity and release controls.

The diagram intentionally has one reporting path. Avoid adding a separate API, cache, or queue in front of Power BI unless there is a concrete application integration requirement. Power BI’s service manages report query execution and caching; the architectural work is to model data, manage refresh and capacity, and control access.

4. Cloud service mapping

Power BI is a Microsoft service; the alternatives below are functional analogues, not interchangeable products or direct compatibility claims. Cross-cloud substitutions change identity integration, administration, connectivity, and deployment tooling.

ComponentChosen Azure serviceAWS analogueGCP analogue
IdentityMicrosoft Entra IDIAM Identity CenterCloud Identity
Ingestion orchestrationAzure Data FactoryAWS Glue or Step FunctionsCloud Data Fusion or Dataflow orchestration
Data lakeAzure Data Lake Storage Gen2Amazon S3Cloud Storage
WarehouseAzure SQL DatabaseAmazon Redshift or Aurora PostgreSQL, depending on workloadBigQuery or Cloud SQL, depending on workload
SecretsAzure Key VaultAWS Secrets ManagerSecret Manager
Logs and metricsAzure Monitor, Log Analytics, Application InsightsCloudWatch, X-RayCloud Monitoring, Cloud Trace
CI/CDAzure DevOpsCodePipeline and CodeBuildCloud Build
BI and semantic layerPower BI semantic models and reportsAmazon QuickSightLooker or Looker Studio

Choose a cloud based on the organization’s identity, data gravity, governance, and operational strengths. Do not assume that moving the warehouse alone makes a Power BI deployment cloud-neutral: gateway placement, network egress, identity, and service administration still matter.

5. Data design

Use a star schema as the default semantic-model shape. Keep transaction-level facts at a declared grain, use conformed dimensions for shared slicing, and place business definitions in the semantic model rather than duplicating them in individual reports.

A representative sales model has one row per order line. The region access table maps a normalized user principal name (UPN) to authorized regions. Keep the access mapping in a controlled source, validate it during ingestion, and refresh it before the semantic model so that a model refresh cannot publish stale permissions.

erDiagram
    DimDate ||--o{ FactSales : dates
    DimProduct ||--o{ FactSales : describes
    DimCustomer ||--o{ FactSales : identifies
    DimRegion ||--o{ FactSales : groups
    DimRegion ||--o{ UserRegion : grants
    DimCustomer ||--o{ FactSales : buys
    DimProduct {
        int ProductKey PK
        string ProductCode
        string ProductName
        string Category
    }
    DimRegion {
        int RegionKey PK
        string RegionCode
        string RegionName
    }
    UserRegion {
        string UPN
        int RegionKey FK
    }
    FactSales {
        bigint SalesKey PK
        int DateKey FK
        int ProductKey FK
        int CustomerKey FK
        int RegionKey FK
        decimal NetAmount
        int Quantity
    }

The warehouse star schema and the user-to-region authorization mapping.

Example Azure SQL DDL:

CREATE TABLE dbo.DimRegion (
    RegionKey   int           NOT NULL PRIMARY KEY,
    RegionCode  varchar(20)   NOT NULL UNIQUE,
    RegionName  nvarchar(100) NOT NULL
);

CREATE TABLE dbo.UserRegion (
    UPN         nvarchar(320) NOT NULL,
    RegionKey   int           NOT NULL,
    CONSTRAINT PK_UserRegion PRIMARY KEY (UPN, RegionKey),
    CONSTRAINT FK_UserRegion_DimRegion
        FOREIGN KEY (RegionKey) REFERENCES dbo.DimRegion(RegionKey)
);

CREATE TABLE dbo.FactSales (
    SalesKey    bigint         NOT NULL PRIMARY KEY,
    DateKey     int            NOT NULL,
    ProductKey  int            NOT NULL,
    CustomerKey int            NOT NULL,
    RegionKey   int            NOT NULL,
    NetAmount   decimal(19, 4) NOT NULL,
    Quantity    int            NOT NULL,
    CONSTRAINT FK_FactSales_DimRegion
        FOREIGN KEY (RegionKey) REFERENCES dbo.DimRegion(RegionKey)
);

In production, add the remaining dimensions and foreign keys, indexes based on actual query plans, and a load process that enforces the declared grain. Partition large facts by date only when measured query and maintenance patterns justify it. Partitioning is not a substitute for incremental refresh or good model design.

For a large imported fact, align Power BI incremental refresh with the warehouse’s date column and retention policy. Validate that the source query folds as expected; a refresh policy that silently forces full scans can turn a capacity problem into a recurring operational incident.

The model’s RLS role filters DimRegion by the user’s authorized regions. One practical expression is:

DimRegion[RegionKey] IN
    SELECTCOLUMNS(
        FILTER(
            UserRegion,
            UserRegion[UPN] = USERPRINCIPALNAME()
        ),
        "RegionKey", UserRegion[RegionKey]
    )

This example assumes normalized UPN values, a correct relationship from DimRegion to FactSales, and a refreshed UserRegion table. Test identities with multiple regions, no mapping, casing differences, renamed accounts, and guest-user behavior. Dynamic RLS is only one layer: consumers must not have a workspace role that bypasses model RLS. Treat export, Analyze in Excel, Build permission, and sharing as separate access decisions.

6. Low-level design

The semantic model is a product with an owner, contract, and release process. Keep measures grouped by subject and give them stable names, descriptions, formats, and documented behavior for blanks and partial periods. A measure such as net sales should be defined once and reused across reports.

classDiagram
    class SourceIngestor {
        +run(batchId)
    }
    class WarehouseLoader {
        +load(batchId)
        +validateGrain()
    }
    class ModelPublisher {
        +validateArtifact()
        +promote(stage)
    }
    class AccessMap {
        +resolve(upn)
    }
    class SemanticModel {
        +measure(name)
        +applyRls(upn)
    }
    SourceIngestor --> WarehouseLoader
    WarehouseLoader --> SemanticModel
    ModelPublisher --> SemanticModel
    AccessMap --> SemanticModel

The small set of responsibilities that keeps ingestion, access, and publication independently testable.

A minimal executable SQL example verifies that the fact grain aggregates as expected:

SELECT
    RegionKey,
    SUM(NetAmount) AS NetSales,
    SUM(Quantity) AS Units
FROM dbo.FactSales
WHERE DateKey >= 20260101
GROUP BY RegionKey;

Notice that the query aggregates the declared order-line fact without joining dimensions that could multiply rows.

A realistic .NET worker can emit an OpenTelemetry span around a warehouse batch. The package references are OpenTelemetry, OpenTelemetry.Exporter.OpenTelemetryProtocol, and OpenTelemetry.Extensions.Hosting; configure the OTLP endpoint for the deployment environment.

using System.Diagnostics;
using OpenTelemetry;
using OpenTelemetry.Trace;

var source = new ActivitySource("Ekanatha.Analytics.Loader");

using var tracer = Sdk.CreateTracerProviderBuilder()
    .AddSource("Ekanatha.Analytics.Loader")
    .AddOtlpExporter()
    .Build();

using var activity = source.StartActivity("warehouse.load");
activity?.SetTag("analytics.batch_id", "sales-2026-11-06");
activity?.SetTag("analytics.subject", "sales");

try
{
    // Replace with the idempotent warehouse load for this batch.
    await Task.Delay(10);
    activity?.SetTag("analytics.load.status", "success");
}
catch (Exception ex)
{
    activity?.SetStatus(ActivityStatusCode.Error, ex.Message);
    throw;
}

Notice that the span records bounded operational attributes, not row-level data, user identifiers, or credentials.

Prefer idempotent loads keyed by source watermark or batch ID. A retry should either complete the same batch safely or fail visibly; it should not duplicate fact rows. Keep orchestration state, source watermarks, and load audit records outside the report model so operators can diagnose freshness without granting broad report access.

7. Key flows

The refresh flow begins with ingestion and ends only after the model has been checked. A successful copy to the lake is not equivalent to fresh reports. Record a batch identifier and source watermark at each handoff, and alert on the end-to-end freshness objective.

sequenceDiagram
    participant S as Source
    participant A as Azure Data Factory
    participant L as ADLS Gen2
    participant W as Azure SQL warehouse
    participant P as Power BI service
    participant O as Azure Monitor
    S->>A: Extract changed data
    A->>L: Write raw batch
    A->>W: Load curated dimensions and facts
    W-->>A: Commit batch and watermark
    A->>P: Trigger semantic model refresh
    P->>W: Read incremental partitions
    P-->>A: Refresh outcome
    A->>O: Emit batch status and freshness

The data freshness flow from source extraction through semantic-model refresh.

The release flow promotes a tested artifact rather than rebuilding different versions for each environment. Environment-specific connections and parameters are configured per stage. Use a deployment identity with only the permissions required to deploy and validate; do not use a human account or a general-purpose administrator identity.

sequenceDiagram
    participant Dev as Developer
    participant CI as Azure DevOps
    participant Test as Test workspace
    participant QA as BI reviewer
    participant Prod as Production workspace
    Dev->>CI: Merge reviewed change
    CI->>CI: Validate model and report artifacts
    CI->>Test: Deploy to test stage
    Test->>QA: Publish candidate for verification
    QA->>CI: Approve promotion
    CI->>Prod: Promote same artifact
    Prod-->>CI: Return deployment result

The release path makes test verification and production approval explicit.

8. Build and release

Store model and report source in version control using a source-controlled representation supported by the chosen authoring workflow. Keep secrets, tenant-specific identifiers, and production connection values out of the repository. Pin tooling versions in the build environment and validate that the chosen format round-trips without unintended changes.

Terraform is appropriate for Azure infrastructure such as storage, SQL, monitoring, and secrets. Power BI workspaces, deployment pipelines, model permissions, and capacity assignments are SaaS configuration; manage them through the organization’s approved Power BI administration and deployment tooling rather than pretending they are ordinary Azure resources.

The following Terraform illustrates the foundation. A production module must also implement the organization’s private networking, private endpoints, DNS, policy, backup, and diagnostic settings before deploying sensitive data.

resource "azurerm_resource_group" "analytics" {
  name     = "rg-analytics-prod"
  location = var.location
}

resource "azurerm_storage_account" "lake" {
  name                     = var.storage_account_name
  resource_group_name      = azurerm_resource_group.analytics.name
  location                 = azurerm_resource_group.analytics.location
  account_tier             = "Standard"
  account_replication_type = "ZRS"
  is_hns_enabled           = true
  min_tls_version          = "TLS1_2"
  shared_access_key_enabled = false
}

resource "azurerm_mssql_server" "warehouse" {
  name                         = var.sql_server_name
  resource_group_name          = azurerm_resource_group.analytics.name
  location                     = azurerm_resource_group.analytics.location
  version                      = "12.0"
  administrator_login          = var.sql_admin_login
  administrator_login_password = var.sql_admin_password
  minimum_tls_version          = "1.2"
}

resource "azurerm_mssql_database" "warehouse" {
  name           = "analytics"
  server_id      = azurerm_mssql_server.warehouse.id
  sku_name       = var.sql_sku
  zone_redundant = true
}

Notice that this is a foundation snippet: use a secret store for credentials and complete private connectivity before production.

A pipeline should separate artifact validation, test deployment, human verification, and production promotion. The exact Power BI deployment endpoint and artifact format should be implemented in a versioned deployment script and validated against the tenant’s current API and capacity configuration.

trigger:
  branches:
    include:
      - main

stages:
  - stage: Validate
    jobs:
      - job: ModelChecks
        pool:
          vmImage: windows-latest
        steps:
          - checkout: self
          - pwsh: ./scripts/validate-model.ps1
            displayName: Validate model, measures, and RLS fixtures
          - publish: $(Build.SourcesDirectory)/artifacts
            artifact: powerbi-artifacts

  - stage: Test
    dependsOn: Validate
    jobs:
      - deployment: DeployTest
        environment: powerbi-test
        strategy:
          runOnce:
            deploy:
              steps:
                - download: current
                  artifact: powerbi-artifacts
                - pwsh: ./scripts/deploy.ps1 -Stage Test
                  displayName: Deploy to test workspace
                - pwsh: ./scripts/smoke-test.ps1 -Stage Test
                  displayName: Run report and security smoke tests

  - stage: Production
    dependsOn: Test
    condition: succeeded()
    jobs:
      - deployment: DeployProduction
        environment: powerbi-production
        strategy:
          runOnce:
            deploy:
              steps:
                - download: current
                  artifact: powerbi-artifacts
                - pwsh: ./scripts/deploy.ps1 -Stage Production
                  displayName: Promote approved artifact

Notice that production approval belongs in the protected environment configuration, not in a developer-controlled script.

Test at four levels:

  • Unit: validate transformation functions, measure definitions where tooling permits, UPN normalization, and access-map integrity.
  • Integration: load representative batches into a non-production warehouse; test refresh, query folding, relationships, and report connections.
  • Contract: compare source schemas and business definitions with agreed contracts; fail on breaking column or grain changes.
  • Load: replay representative report interactions and refreshes at expected peak concurrency. Measure capacity utilization, refresh duration, and query latency; do not infer production headroom from a small developer model.

For RLS, run positive and negative tests for each role: authorized rows appear, unauthorized rows do not, and unmapped users see no protected rows. Include a test proving that consumer accounts are not workspace Admin, Member, or Contributor. A successful DAX expression alone is not a security test.

9. Observability

Monitor the full data-to-report journey. Power BI service telemetry and Azure infrastructure telemetry are different views: correlate them with refresh IDs, deployment IDs, batch IDs, model names, and environment. Do not log raw report data, access tokens, or unnecessary personal identifiers.

A structured event for a refresh worker might look like:

{
  "timestamp": "2026-11-06T07:12:31Z",
  "level": "Information",
  "service": "analytics-loader",
  "environment": "production",
  "batch_id": "sales-2026-11-06",
  "subject": "sales",
  "event": "semantic_refresh_completed",
  "duration_ms": 184200,
  "rows_loaded": 1284000,
  "result": "success"
}

Notice that identifiers support correlation while the event avoids including row contents or user data.

Use RED for request-serving components and USE for infrastructure resources:

MethodSignals to monitor
RED — RateWarehouse load runs, model refreshes, report queries where available, deployment attempts
RED — ErrorsFailed or timed-out refreshes, failed warehouse loads, query errors, deployment failures
RED — DurationLoad time, refresh time, query latency, pipeline duration
USE — UtilizationSQL CPU, storage throughput, Fabric/Power BI capacity utilization
USE — SaturationCapacity throttling, SQL resource pressure, queue depth for any ingestion buffer
USE — ErrorsSQL connection failures, storage errors, capacity rejection or throttling

The .NET tracing example in section 6 creates an OTLP-exported span for a warehouse load. Extend the same trace across the worker’s database calls and orchestration activities where instrumentation supports it. Power BI’s internal visual-query execution is not automatically a child span of a custom application trace; correlate service-side telemetry using refresh or activity identifiers instead of claiming end-to-end trace propagation that is not present.

SLIInitial SLO
Report availability during business hours99.9% successful synthetic checks per month
Data freshness for daily sales model99% of business days complete by 07:00 local time
Refresh reliability99% of scheduled refreshes complete without manual intervention
Common report interaction latency95% under 5 seconds in the defined representative test set

Dashboards should show data freshness by subject, refresh duration and outcome, pipeline batch state, SQL resource use, capacity utilization and throttling, report synthetic-check results, and deployment history. Break down trends by environment and model; an organization-wide average can hide a broken business-critical model.

Page on a sustained production freshness breach, repeated model refresh failure, report availability below the SLO, capacity throttling that affects users, and suspected unauthorized access. Notify rather than page for a single transient retry, a non-production failure, or a cost trend with no immediate service impact. Every alert should identify an owner and link to a runbook.

10. Security and compliance

Security boundaries must be enforced in both the workspace and the semantic model. RLS filters data for consumers; it does not replace authentication, workspace permissions, or controls over sharing and export.

  • Use Entra groups for workspace roles, app audiences, and model permissions. Review group membership and ownership regularly.
  • Keep consumers out of elevated workspace roles. Admin, Member, and Contributor access can bypass RLS behavior expected of viewers.
  • Give authors separate development workspaces. Publish reviewed content through controlled stages rather than allowing direct production edits.
  • Store source credentials in Key Vault or an approved managed identity flow. Prefer managed identity for Azure data access where supported.
  • Restrict data connectivity using private networking and approved gateways as appropriate. Validate DNS, routing, and outbound access before making a model dependent on a private source.
  • Treat export, download, Build permission, sharing, and Analyze in Excel as distinct data exposure paths. Apply sensitivity labels and tenant controls according to policy.
  • Maintain auditable records of access-map changes, workspace changes, refreshes, and promotions. Define retention based on regulatory and operational requirements.
  • Test RLS using actual consumer identities, including guests and users with multiple group memberships. Do not use an administrator account as the only security test identity.

For sensitive data, decide whether data should be excluded from a shared model entirely. RLS is valuable for row-level segmentation, but separate models or workspaces may be a better control where legal, contractual, or operational boundaries require distinct administration.

11. Cost

The following is an assumption-based monthly estimate, not a quote. Azure and Power BI prices vary by region, capacity choice, licensing, commitment, usage, and negotiated terms. Confirm current prices with the relevant vendor calculators and procurement team before committing.

Cost areaPlanning range / monthAssumption
Power BI/Fabric capacity$6,000–$15,000One capacity sized after workload testing; final SKU and licensing require validation
User licenses$2,000–$5,000Assumed mix of viewers and authors; actual entitlement model can materially change cost
Azure SQL Database$1,500–$3,500Production warehouse tier with zone redundancy and test capacity accounted for
ADLS Gen2$200–$800Approximately 1 TB stored plus daily changes, operations, and retention
Data Factory and integration$300–$1,200Scheduled ingestion with moderate activity and transfer
Monitoring, Key Vault, networking$300–$1,000Log retention and private networking depend on volume and configuration
Estimated total$10,300–$26,500Excludes labor, source-system charges, taxes, and one-time migration

Capacity is often the dominant variable, so optimize model size, refresh design, DAX, and report interaction patterns before scaling up. Keep development and test workloads bounded and schedule heavy refreshes away from peak viewing where business requirements permit. Review capacity metrics and actual user demand monthly; do not use low storage cost as evidence that the overall BI service is inexpensive.

12. Failure modes, resilience and disaster recovery

Failure modeUser impactResponse
Source is late or unavailableStale reportsMark freshness visibly, retry with bounded backoff, and alert on the freshness SLO.
Warehouse load partially completesInconsistent totalsUse batch tracking and idempotent loads; publish a batch only after validation and commit.
Model refresh failsLast successful model remains available, but data is staleRetry transient failures, preserve last known good model, and investigate capacity or source errors.
RLS mapping is empty or malformedUsers see no rows or an incorrect scopeValidate mappings before refresh; fail closed and alert on unexpected mapping changes.
Capacity is saturatedSlow queries or failed refreshesInspect workload and throttling, stagger refresh, optimize model, then resize based on measurements.
Production deployment is incorrectBroken reports or model behaviorStop promotion, restore prior artifact or redeploy the last known good version, and verify smoke tests.
Region or service disruptionReporting unavailableFollow Microsoft service-health guidance and the organization’s continuity plan; communicate freshness and recovery state.

The architecture is not automatically multi-region disaster recovery. Define recovery point and recovery time objectives with business owners, then test the actual recovery steps: rebuild or restore the warehouse, recreate model and workspace configuration from controlled artifacts, restore access mappings, and validate report behavior. Keep deployment artifacts and infrastructure state protected separately from the production workspace.

A second region adds cost and operational complexity, and it does not guarantee that Power BI tenant or capacity dependencies fail over as the organization expects. Confirm product-specific recovery options and tenant constraints before promising regional continuity. For this scale, documented restore and redeploy procedures may be a more proportionate first step than duplicating the entire analytics estate.

13. Evolving to the next scale

Change the design in response to measured bottlenecks and new organizational boundaries, not user counts alone.

  • When refresh windows become unreliable: inspect query folding, source scan volume, partitions, and refresh concurrency. Consider a more suitable warehouse engine or a Fabric-oriented data platform if its capabilities and governance fit the workload.
  • When interactive queries saturate capacity: simplify high-cardinality models, reduce unnecessary columns, optimize measures and visuals, and separate refresh-heavy workloads. Scale capacity only after profiling.
  • When teams need independent release cadence: split models by subject area with clear data contracts and owners. Avoid both a single giant model that blocks change and dozens of small models that duplicate semantics.
  • When access rules become complex: formalize access-map ownership, synchronization, audit, and automated policy tests. Consider separate models or workspaces for hard security boundaries.
  • When external users need embedded analytics: redesign identity, tenant isolation, licensing, throttling, and application authorization as a distinct architecture. Internal-user RLS assumptions are not sufficient.
  • When the organization spans clouds or regions: make data residency, egress, identity federation, and recovery guarantees explicit. Keep a single semantic contract where useful, not necessarily a single physical warehouse.

Any change that increases model count or capacity should come with an owner, a migration plan, and evidence from production-like tests. “More workspaces” is not itself a scaling strategy.

14. Phased implementation plan

  1. Define measures and ownership. Select one business domain, write down metric definitions and fact grain, nominate model and data owners, and agree freshness and availability targets.
  2. Build the data foundation. Provision the lake and warehouse with private connectivity, managed identities, access logging, and repeatable infrastructure deployment. Implement idempotent ingestion and load auditing.
  3. Create the first certified model. Build a star schema, define shared measures, configure incremental refresh where appropriate, and document model permissions and report ownership.
  4. Prove security before broad release. Implement dynamic RLS from governed access data. Test authorized, unauthorized, unmapped, guest, and multi-region identities using consumer-level permissions.
  5. Automate promotion. Put source artifacts and validation scripts in version control. Deploy to test, run data and report checks, require review, then promote the same artifact to production.
  6. Instrument and load test. Measure freshness, refresh duration, query latency, capacity use, and warehouse pressure with representative models and user behavior. Tune or resize from evidence.
  7. Expand by domain. Add further subject areas only when their definitions, owners, and release paths are clear. Review access, cost, and operational incidents after each expansion.

The production-readiness gate is not “the report looks right on the author’s account.” It is a reproducible model release, verified data freshness, tested consumer RLS, measured performance at expected load, and a team that can identify and recover from a failed refresh or deployment.


This article was generated with AI. #AIGenerated