Home > Docs > Best Practices > FinOps & Cost Governance

💸 FinOps & Cost Governance for Microsoft Fabric¶

Last Updated: 2026-04-21 | Version: 1.0.0

📑 Table of Contents¶

• 🎯 Overview
• 📊 FinOps Framework for Fabric
• 💰 Cost Allocation & Chargeback
• 📐 Capacity Right-Sizing
• ⏸️ Pause/Resume Automation
• 🔔 Budget Alerts & Action Groups
• 📈 CU Consumption Monitoring
• ⚡ Smoothing vs Bursting
• 🔧 Cost Optimization Strategies
• 🎰 Casino Implementation
• 🏛️ Federal Implementation
• 🚫 Limitations
• 📚 References

🎯 Overview¶

FinOps (Cloud Financial Operations) brings financial accountability to Fabric's consumption-based model. Unlike traditional fixed-infrastructure costs, Fabric's Capacity Unit (CU) model requires continuous monitoring, optimization, and cross-functional collaboration between engineering, finance, and business teams.

Why FinOps for Fabric?¶

FinOps Maturity Levels¶

flowchart LR
    subgraph Crawl["🐛 Crawl"]
        style Crawl fill:#E67E22,color:#fff
        C1[Basic cost visibility]
        C2[Manual budget tracking]
        C3[Reactive scale decisions]
    end

    subgraph Walk["🚶 Walk"]
        style Walk fill:#2471A3,color:#fff
        W1[Workspace-level allocation]
        W2[Automated budget alerts]
        W3[Scheduled pause/resume]
    end

    subgraph Run["🏃 Run"]
        style Run fill:#27AE60,color:#fff
        R1[Real-time chargeback]
        R2[Auto-scale policies]
        R3[FinOps KPIs in Gold layer]
    end

    Crawl --> Walk --> Run

📊 FinOps Framework for Fabric¶

The FinOps Foundation defines three phases: Inform, Optimize, and Operate. Each maps directly to Fabric capabilities.

Phase 1: Inform¶

Build visibility into who is consuming what and at what cost.

// Weekly cost trend by workspace
FabricCapacityMetrics
| where TimeGenerated > ago(30d)
| summarize
    TotalCU = sum(CUSeconds) / 3600.0,
    AvgCUPercent = avg(CUPercentage)
    by bin(TimeGenerated, 1d), WorkspaceName
| render timechart

Phase 2: Optimize¶

Reduce waste and improve unit economics.

Phase 3: Operate¶

Embed FinOps into organizational processes.

graph TD
    subgraph Inform["Phase 1: Inform"]
        style Inform fill:#6C3483,color:#fff
        I1[Capacity Metrics App]
        I2[Azure Cost Management]
        I3[CU Trend Dashboard]
    end

    subgraph Optimize["Phase 2: Optimize"]
        style Optimize fill:#2471A3,color:#fff
        O1[Right-Size SKU]
        O2[Pause/Resume]
        O3[Reserved Capacity]
        O4[Query Optimization]
    end

    subgraph Operate["Phase 3: Operate"]
        style Operate fill:#27AE60,color:#fff
        P1[Budget Alerts]
        P2[Auto-Scale Policies]
        P3[Monthly FinOps Review]
        P4[Chargeback Reports]
    end

    I1 --> O1
    I2 --> O2
    I3 --> O3
    O1 --> P1
    O2 --> P2
    O3 --> P3
    O4 --> P4

💰 Cost Allocation & Chargeback¶

Chargeback vs Showback¶

Cost Allocation Architecture¶

flowchart TB
    subgraph Capacity["F64 Shared Capacity"]
        style Capacity fill:#6C3483,color:#fff
        WS1["ws_etl<br/>Data Engineering"]
        WS2["ws_analytics<br/>Analytics Team"]
        WS3["ws_bi<br/>BI / Reporting"]
        WS4["ws_datascience<br/>Data Science"]
    end

    subgraph Metrics["Capacity Metrics"]
        style Metrics fill:#2471A3,color:#fff
        M1[CU-seconds per workspace]
        M2[Storage bytes per lakehouse]
        M3[Pipeline activity counts]
    end

    subgraph Allocation["Cost Allocation"]
        style Allocation fill:#27AE60,color:#fff
        A1["Data Engineering: 40% CU"]
        A2["Analytics: 25% CU"]
        A3["BI / Reporting: 20% CU"]
        A4["Data Science: 15% CU"]
    end

    Capacity --> Metrics --> Allocation

Chargeback Calculation¶

def calculate_chargeback(
    capacity_monthly_cost: float,
    workspace_cu_seconds: dict[str, float],
    shared_overhead_pct: float = 0.10,
) -> dict:
    """
    Calculate workspace-level chargeback with shared overhead.

    Args:
        capacity_monthly_cost: Total monthly capacity cost (e.g., $8,410 for F64)
        workspace_cu_seconds: Dict of workspace_name -> total CU-seconds consumed
        shared_overhead_pct: Percentage allocated to shared/platform costs
    """
    shared_cost = capacity_monthly_cost * shared_overhead_pct
    allocatable_cost = capacity_monthly_cost - shared_cost
    total_cu = sum(workspace_cu_seconds.values())

    result = {"_shared_platform": round(shared_cost, 2)}
    for ws, cu in workspace_cu_seconds.items():
        proportion = cu / total_cu if total_cu > 0 else 0
        result[ws] = {
            "cu_seconds": cu,
            "proportion": round(proportion, 4),
            "cost": round(allocatable_cost * proportion, 2),
        }
    return result

Azure Tags for Cost Allocation¶

resource fabricCapacity 'Microsoft.Fabric/capacities@2023-11-01' = {
  name: capacityName
  location: location
  sku: { name: skuName, tier: 'Fabric' }
  tags: {
    CostCenter: costCenterCode
    Department: department
    Environment: environment
    FinOpsOwner: finopsOwnerEmail
    BudgetCode: budgetCode
    ChargebackModel: 'proportional-cu'
  }
}

📐 Capacity Right-Sizing¶

Right-Sizing Decision Matrix¶

SKU Migration Path¶

flowchart LR
    F2["F2<br/>$263/mo<br/>Solo dev"] --> F4["F4<br/>$526/mo<br/>Small team"]
    F4 --> F8["F8<br/>$1,051/mo<br/>Dev/POC"]
    F8 --> F16["F16<br/>$2,102/mo<br/>Team dev"]
    F16 --> F32["F32<br/>$4,205/mo<br/>Small prod"]
    F32 --> F64["F64<br/>$8,410/mo<br/>POC target"]
    F64 --> F128["F128<br/>$16,819/mo<br/>Medium prod"]
    F128 --> F256["F256<br/>$33,638/mo<br/>Large prod"]

    style F64 fill:#34a853,color:#fff

Tip: Start with F8 for development, F64 for POC/small production. Scale based on 2 weeks of observed P95 CU metrics, not estimates.

⏸️ Pause/Resume Automation¶

Azure Automation Runbook¶

# Azure Automation runbook (Python 3)
import automationassets
from azure.identity import DefaultAzureCredential
from azure.mgmt.fabric import FabricMgmtClient

SUBSCRIPTION_ID = automationassets.get_automation_variable("SubscriptionId")
RESOURCE_GROUP = automationassets.get_automation_variable("ResourceGroup")
CAPACITY_NAME = automationassets.get_automation_variable("CapacityName")

credential = DefaultAzureCredential()
client = FabricMgmtClient(credential, SUBSCRIPTION_ID)

def pause_capacity():
    """Pause Fabric capacity to stop billing."""
    client.capacities.begin_suspend(RESOURCE_GROUP, CAPACITY_NAME).result()
    print(f"✅ Capacity {CAPACITY_NAME} paused successfully")

def resume_capacity():
    """Resume Fabric capacity."""
    client.capacities.begin_resume(RESOURCE_GROUP, CAPACITY_NAME).result()
    print(f"✅ Capacity {CAPACITY_NAME} resumed successfully")

Logic App Schedule (Recommended)¶

Pause/Resume Bicep Alert¶

resource pauseSchedule 'Microsoft.Logic/workflows@2019-05-01' = {
  name: 'fabric-pause-dev'
  location: location
  properties: {
    definition: {
      '$schema': 'https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#'
      triggers: {
        Recurrence: {
          type: 'Recurrence'
          recurrence: {
            frequency: 'Week'
            interval: 1
            schedule: {
              weekDays: ['Monday','Tuesday','Wednesday','Thursday','Friday']
              hours: [19]
              minutes: [0]
            }
            timeZone: 'Eastern Standard Time'
          }
        }
      }
    }
  }
}

🔔 Budget Alerts & Action Groups¶

Azure Budgets Configuration¶

resource fabricBudget 'Microsoft.Consumption/budgets@2023-11-01' = {
  name: 'fabric-monthly-budget'
  properties: {
    category: 'Cost'
    amount: monthlyBudgetAmount
    timeGrain: 'Monthly'
    timePeriod: {
      startDate: '2026-04-01'
    }
    notifications: {
      Warning75: {
        enabled: true
        operator: 'GreaterThanOrEqualTo'
        threshold: 75
        contactEmails: [ finopsTeamEmail ]
        thresholdType: 'Actual'
      }
      Critical90: {
        enabled: true
        operator: 'GreaterThanOrEqualTo'
        threshold: 90
        contactEmails: [ finopsTeamEmail, managerEmail ]
        thresholdType: 'Actual'
      }
      Exceeded100: {
        enabled: true
        operator: 'GreaterThanOrEqualTo'
        threshold: 100
        contactEmails: [ finopsTeamEmail, managerEmail, directorEmail ]
        thresholdType: 'Actual'
      }
      Forecast110: {
        enabled: true
        operator: 'GreaterThanOrEqualTo'
        threshold: 110
        contactEmails: [ finopsTeamEmail, managerEmail ]
        thresholdType: 'Forecasted'
      }
    }
  }
}

Alert Escalation Matrix¶

📈 CU Consumption Monitoring¶

Capacity Metrics KQL Queries¶

// Hourly CU consumption heatmap (workspace breakdown)
FabricCapacityMetrics
| where TimeGenerated > ago(7d)
| summarize AvgCU = avg(CUPercentage) by
    bin(TimeGenerated, 1h),
    WorkspaceName
| evaluate pivot(WorkspaceName, avg(AvgCU))
| render timechart

// Identify top CU-consuming operations
FabricCapacityMetrics
| where TimeGenerated > ago(24h)
| summarize
    TotalCUSeconds = sum(CUSeconds),
    OperationCount = count()
    by WorkloadType, WorkspaceName
| top 10 by TotalCUSeconds desc

CU Consumption Dashboard (Gold Layer)¶

# Gold table: Daily CU cost allocation
df_cu_allocation = (
    spark.table("lh_gold.fact_capacity_metrics")
    .groupBy("metric_date", "workspace_name", "workload_type")
    .agg(
        F.sum("cu_seconds").alias("total_cu_seconds"),
        F.avg("cu_percentage").alias("avg_cu_pct"),
        F.max("cu_percentage").alias("peak_cu_pct"),
    )
    .withColumn("estimated_daily_cost",
        F.col("total_cu_seconds") / F.lit(86400) * F.lit(DAILY_CAPACITY_COST)
    )
)

⚡ Smoothing vs Bursting¶

Fabric smooths CU consumption over time windows to handle short spikes without throttling.

Smoothing Windows¶

Burst vs Sustained¶

graph LR
    subgraph Burst["✅ Burst (Smoothed)"]
        style Burst fill:#27AE60,color:#fff
        B1["Short spike to 150% CU<br/>Duration: 30 seconds<br/>Result: No throttling"]
    end

    subgraph Sustained["❌ Sustained Overuse"]
        style Sustained fill:#E74C3C,color:#fff
        S1["Constant 120% CU<br/>Duration: 4+ hours<br/>Result: Throttling begins"]
    end

Key Insight: Fabric's smoothing means you do NOT need to size your SKU for peak instantaneous CU. Size for sustained P95 over a 5-minute window. Short bursts are absorbed by the smoothing mechanism.

🔧 Cost Optimization Strategies¶

🎰 Casino Implementation¶

Cost Allocation per Property/Department¶

Casino operators typically allocate Fabric costs across properties (individual casino locations) and departments (Slots, Table Games, Compliance, Marketing).

# Casino chargeback: property + department allocation
CASINO_COST_CENTERS = {
    "ws_slots_vegas":       {"property": "Las Vegas", "department": "Slots"},
    "ws_tables_vegas":      {"property": "Las Vegas", "department": "Table Games"},
    "ws_compliance_vegas":  {"property": "Las Vegas", "department": "Compliance"},
    "ws_slots_atlantic":    {"property": "Atlantic City", "department": "Slots"},
    "ws_marketing":         {"property": "Corporate", "department": "Marketing"},
}

def casino_chargeback(capacity_cost: float, ws_cu: dict) -> dict:
    """Allocate costs by property and department."""
    total_cu = sum(ws_cu.values())
    result = {}
    for ws, cu in ws_cu.items():
        meta = CASINO_COST_CENTERS[ws]
        prop = meta["property"]
        dept = meta["department"]
        cost = capacity_cost * (cu / total_cu) if total_cu > 0 else 0
        result.setdefault(prop, {})
        result[prop][dept] = round(cost, 2)
    return result

Casino FinOps KPIs¶

Casino Pause/Resume Schedule¶

Casino production runs 24/7 but development and analytics workspaces can be paused:

🏛️ Federal Implementation¶

OMB Compliance for Cloud Cost Reporting¶

Federal agencies must comply with OMB Circular A-123 and the FITARA scorecard for IT cost management. Fabric FinOps must produce auditable cost reports aligned with these requirements.

Federal Agency Cost Reporting¶

# Federal chargeback aligned with TBM cost towers
FEDERAL_TBM_MAPPING = {
    "ws_usda_analytics": {"agency": "USDA", "tbm_tower": "Data Management", "tas": "12-1234"},
    "ws_sba_loans":      {"agency": "SBA",  "tbm_tower": "Data Management", "tas": "73-5678"},
    "ws_noaa_weather":   {"agency": "NOAA", "tbm_tower": "Analytics",       "tas": "13-9012"},
    "ws_epa_monitoring": {"agency": "EPA",  "tbm_tower": "Data Management", "tas": "68-3456"},
    "ws_doi_resources":  {"agency": "DOI",  "tbm_tower": "Analytics",       "tas": "14-7890"},
}

def federal_cost_report(capacity_cost: float, ws_cu: dict) -> list[dict]:
    """Generate OMB-compliant cost allocation report."""
    total_cu = sum(ws_cu.values())
    report = []
    for ws, cu in ws_cu.items():
        meta = FEDERAL_TBM_MAPPING[ws]
        report.append({
            "agency": meta["agency"],
            "tbm_tower": meta["tbm_tower"],
            "treasury_account_symbol": meta["tas"],
            "cu_seconds": cu,
            "proportion": round(cu / total_cu, 4) if total_cu > 0 else 0,
            "allocated_cost": round(capacity_cost * cu / total_cu, 2) if total_cu > 0 else 0,
            "fiscal_year": "FY2026",
            "fiscal_quarter": "Q3",
        })
    return report

FedRAMP Cost Overhead¶

🚫 Limitations¶

📚 References¶

Microsoft Documentation¶

• Microsoft Fabric pricing
• Fabric capacity and SKUs
• Fabric capacity metrics app
• Pause and resume capacity
• Smoothing and bursting
• Throttling in Fabric
• Azure reservations for Fabric

Azure Cost Management¶

• Azure Cost Management best practices
• Create and manage Azure budgets
• Azure Automation runbook overview
• Logic Apps recurrence triggers

FinOps & Federal Compliance¶

• FinOps Foundation framework
• OMB Circular A-123
• FITARA scorecard
• TBM taxonomy
• Federal Cloud Smart strategy

Related Documents¶

• Capacity Planning & Cost Optimization — SKU sizing and CU optimization strategies
• Alerting & Data Activator — Automated alerting patterns
• Disaster Recovery & BCDR — DR capacity cost planning
• Multi-Tenant Workspace Architecture — Workspace isolation for cost allocation
• Monitoring & Observability — Capacity metrics monitoring

Document Metadata¶

Back to Best Practices Index | Back to Documentation