Microsoft Fabric

Microsoft Fabric Capacity Explained: CUs, Smoothing, Throttling and Sizing

Where Fabric capacity actually goes: what consumes Capacity Units, how smoothing and throttling work, how to investigate a spike in the Capacity Metrics app, and how to size without guessing.

Par JaviPublié 20 min de lectureIntermédiaire

The most common misunderstanding about Microsoft Fabric capacity is that it is a server. “We have an F64, so we have a machine with so many cores, and when it is busy, things slow down.” That mental model produces the wrong diagnosis almost every time. (If you come from SQL Server, SQL Server to Microsoft Fabric: What Maps to What? explains why a capacity is only partly like an instance.)

A Fabric capacity is a budget of compute, shared by every workspace assigned to it and measured in Capacity Units (CUs). If you need the platform basics first, start with What Is Microsoft Fabric?. Notebooks, pipelines, Warehouse queries, semantic model refreshes and report interactions all draw from the same budget, each through its own engine and its own consumption rate. Fabric lets operations temporarily use more than the budget and then spreads the cost over time. So the moment users feel pain is often not the moment the expensive work ran.

That is why “is the capacity too small?” is rarely the first useful question. The useful ones are:

  • Which operation consumed the CUs?
  • How long did it consume them?
  • Was it interactive or background?
  • Did smoothing move the impact to a later time?
  • Are workloads interfering with each other on the same capacity?

Capacity problems are usually workload-shape problems before they are SKU problems. This article explains how consumption is measured, how smoothing and throttling behave, how to investigate a spike, and how to make sizing decisions from evidence. It deliberately contains no prices and no “F16 handles X rows” table, because no honest version of that table exists.

The throttling and smoothing behavior described here follows Microsoft’s documentation as of October 2026. Microsoft states that it may change the throttling policy, so check the current throttling documentation before relying on specific numbers.

What is a Capacity Unit?

A Capacity Unit (CU) is Fabric’s common measure of compute. An F SKU’s number is its CU count: an F2 provides 2 CUs, an F64 provides 64, an F2048 provides 2,048. The trial capacity is equivalent to 64 CUs.

The unit of consumption is the CU second: one CU used for one second. An F64 therefore has a budget of 64 CU seconds every second, or 1,920 CU seconds in each 30-second timepoint, the interval the Capacity Metrics app reports in.

Each workload converts its own raw usage into CUs at its own rate. A few documented conversions show how different the engines are:

  • Spark: two Spark VCores equal one CU.
  • Data Warehouse and SQL analytics endpoint: one Warehouse core equals a published fraction of a CU.
  • Power BI: eight CUs equal one Power BI v-core.
  • Pipelines: copy activities are charged by data movement time and data integration units; other activities by activity runs.

Do not turn any of these into “a CU is a CPU core”. The rates differ by workload, Microsoft can change them, and they describe how usage is billed against the budget, not the hardware you get. The practical takeaway is simpler: every workload spends the same currency, at different exchange rates.

  1. Workloads
    • Notebook
    • Pipeline
    • Warehouse
    • Power BI
  2. Shared Fabric capacityOne CU budget per F SKU
  3. CU consumptionEach workload at its own rate
  4. SmoothingInteractive over minutes, background over 24 hours
    • within budget
      NormalKeep monitoring trends
    • sustained overuse
      Capacity pressureInvestigate, then act
      • Optimize
      • Reschedule
      • Isolate
      • Resize
How workloads share one Fabric capacity. Every workload in the capacity's workspaces spends the same CU budget. Smoothing spreads the cost over time; only sustained overuse turns into capacity pressure.

A capacity is assigned at the workspace level. Every item in a workspace consumes from that workspace’s capacity, and a tenant can have as many capacities as it needs. SKU size also changes some licensing behavior, not just compute. For example, users with only a free license can view Power BI content in a workspace only when its capacity is F64 or larger. Check that before downsizing a capacity that serves reports.

What consumes Fabric capacity?

Every operation that does work against an item consumes CUs. The table summarizes the workloads you will meet first. Do not compare rows directly: a CU second of Spark and a CU second of a DAX query are the same budget, but they come from different engines with different shapes.

Workload Typical operation Consumption pattern Common surprise Best place to investigate
Spark notebooks and Spark job definitions Notebook run (manual, scheduled, pipeline), Spark job run Background. Cost follows session size × duration, including idle time while the session is alive Manual notebook runs count as background too; an idle interactive session still holds cores Capacity Metrics by item, then the Spark monitoring and session details
Pipelines (Data Factory) Copy activity (DataMovement), other activities (ActivityRun) Background. Copy cost follows duration and data integration units Many small copies or retry loops add up; the notebooks a pipeline calls are charged as Spark, not as the pipeline Capacity Metrics by pipeline item, then pipeline run history
Dataflow Gen2 Dataflow evaluation (Dataflow Gen2 Run Queries) plus staging Background Staging can add SQL endpoint usage on top of the dataflow itself Capacity Metrics by dataflow item
Warehouse and SQL analytics endpoint T-SQL queries, user-generated and system-generated Reported almost entirely as background, so smoothed over 24 hours A daytime burst of heavy queries can keep weighing on the capacity for the rest of the day Capacity Metrics, then query insights in the Warehouse
SQL database in Fabric Queries and data changes Interactive Operational traffic follows application load, not your batch schedule Capacity Metrics by database item
Power BI semantic models Scheduled and on-demand refresh (background); report and DAX queries (interactive) Refreshes are background; user queries are interactive and smoothed over minutes Refresh concurrency at the top of the hour; a heavy model makes every slicer click expensive Capacity Metrics by semantic model, split by operation
Direct Lake semantic models Interactive queries reading Delta tables Interactive queries Poorly maintained source tables (many small files, wide scans) cost more on every query Capacity Metrics plus the source tables’ file layout
Eventhouse and Real-Time Intelligence Eventhouse uptime, eventstream processing Background, and largely continuous while active A continuously active Eventhouse is a steady baseline, not a spike Capacity Metrics by Eventhouse and eventstream items
OneLake operations Reads, writes and other storage transactions Background Chatty access patterns, such as many small reads and writes, show up as compute, not just storage Capacity Metrics, OneLake operations

Two classifications deserve emphasis because they surprise most teams:

  • All Spark notebook runs are background operations, including a notebook you run by hand. Spark pressure is mostly a 24-hour problem, not a minutes problem.
  • Warehouse and SQL endpoint queries are almost all reported as background. That deliberately gives them 24-hour smoothing. It also means a morning of heavy ad hoc SQL adds to the background load that the rest of the day has to carry.

Spark also has its own admission layer on top of capacity. Each CU gives two Spark VCores, and Fabric allows bursting up to three times the purchased VCores for concurrency. When the available Spark cores are in use, jobs started from pipelines, schedules and Spark job definitions queue (first in, first out, with a queue expiry). Interactive notebook runs are not queued; they fail with a TooManyRequestsForCapacity error instead. When the whole capacity is throttled, new Spark jobs are rejected rather than queued. “My notebook could not start” can therefore be a Spark concurrency limit, not CU throttling. The two are investigated differently.

Interactive vs background operations

Fabric classifies every operation as interactive or background, and the classification decides how its cost is smoothed and how throttling treats it.

  • Interactive: on-demand requests a user is typically waiting for. Opening a report, clicking a slicer, a DAX query from SSMS, queries against SQL database in Fabric. They are short but frequent, and they arrive in bursts that follow people’s working hours.
  • Background: longer-running work nobody waits on interactively. Refreshes, pipelines, Spark, most Warehouse work. These are long and heavy, and often scheduled together.

The practical consequences:

  • Short interactive spikes are smoothed over minutes, so a burst of report usage shows up in the capacity almost immediately and fades quickly.
  • Background jobs are smoothed over 24 hours, so a single large job barely moves the needle, but many large jobs accumulate into a high, slow-moving baseline.
  • Throttling protects background work longest. Interactive operations are delayed and then rejected before background operations are. So background load is often what causes user-visible problems: it fills the future capacity, and the interactive users hit the throttling limits first.
  • Concurrency multiplies everything. Ten pipelines that each look modest can become the dominant load when they all start at 02:00, and twenty analysts on a heavy report can do the same at 09:00.

Classification is decided when an operation is submitted, so occasionally an operation is classified one way and smoothed the other. When in doubt, Fabric falls back to background.

Smoothing

Fabric lets an operation run as fast as it can, even if that briefly uses more compute than the SKU provides. Microsoft calls this bursting. To avoid penalizing the burst, Fabric then smooths the operation’s CU usage, spreading it across future timepoints:

  • Interactive operations are smoothed over at least five minutes and up to 64 minutes, depending on how much they consume.
  • Background operations are smoothed over 24 hours.

An illustrative example, using the documented rules and invented workload numbers: on an F64, a nightly notebook consumes the equivalent of 64 CUs for one hour, which is 64 CU hours. Smoothed over 24 hours, that adds about 2.7 CUs to every timepoint for the next day, roughly 4% of an F64’s budget. The job “used the whole capacity” while it ran, yet its lasting footprint is small.

Now run twenty such jobs, plus refreshes, plus a busy Warehouse. Each adds its own slice to every future timepoint, and the slices stack. The capacity looks fine for hours because no single operation is large. Then interactive users arrive, add their own minutes-scale spikes on top of a baseline that is already near the limit, and the capacity starts to throttle.

Smoothing explains three diagnostic puzzles:

  • The impact can appear after the cause has finished. The job that filled the capacity may have completed hours ago.
  • The current moment can look quiet while the capacity is still overloaded. Smoothed usage from earlier work is still being paid off.
  • The operation running when users complain is often not the cause. It is the operation that happened to tip an already-full capacity over the line.

Throttling

Throttling is what happens when smoothed usage exceeds what the capacity can pay for. It is applied per capacity: an overloaded capacity throttles its own workspaces while other capacities run normally.

Fabric measures how much future capacity has already been committed by smoothed usage, then escalates in stages. As documented in October 2026:

Stage Trigger (future capacity already used) Effect
Overage protection Up to 10 minutes No throttling. The capacity absorbs the surge
Interactive delay More than 10 minutes, up to 60 minutes New interactive operations are delayed by 20 seconds at submission
Interactive rejection More than 60 minutes, up to 24 hours New interactive operations are rejected; background operations can still start
Background rejection More than 24 hours All new requests, interactive and background, are rejected

When usage exceeds the capacity in a timepoint, the excess is an overage. Overage beyond the protection window becomes carryforward, which is paid down in later timepoints that have spare capacity. This is called burndown. Throttling continues until the carryforward is paid off.

What users see:

  • Delays first: reports and queries that feel sluggish for no obvious reason.
  • Rejections next, with errors such as CapacityLimitExceeded, “Your organization’s Fabric compute capacity has exceeded its limits. Try again later”, or “Cannot load model due to reaching capacity limits”.
  • Operations that were already running keep running. Throttling only affects operations requested after it starts.

A few behaviors are worth knowing:

  • Real-Time Intelligence skips the interactive-delay stage and only throttles from the rejection stage, because a 20-second delay would defeat its purpose. Eventstreams reduce the resources they get rather than being stopped.
  • Utilization above 100% is not the same as throttling. Overage protection exists precisely so that short surges do not throttle. Check the throttling charts, not just the utilization line.
  • A quiet moment is not recovery. The capacity has recovered when the carryforward has burned down, not when the last job finished.

Capacity admins can also enable surge protection, which rejects new background operations earlier, at an admin-defined threshold, to keep room for interactive users. Workspace-level surge protection, which caps a single workspace’s consumption, was in preview at the time of writing. Both are controls, not substitutes for fixing the workload that caused the surge.

Why capacity surprises happen

The causes repeat across platforms:

  • Too much notebook concurrency. Many pipelines starting notebooks at the same time, each with its own session. Session sharing through session tags reduces the number of sessions where the workload allows it.
  • Oversized or idle Spark sessions. A session sized for the largest job runs the small ones too, and an interactive session left open holds its cores until it times out.
  • Long-running background transformations that read far more than they need. Make Fabric notebooks faster covers reading less, shuffling less and writing efficiently.
  • Repeated full reloads. Rewriting a whole table every hour to pick up a few changed rows is the most common avoidable background load. Incremental loads are the structural fix.
  • Inefficient SQL. Wide scans, missing filters and repeated heavy reporting queries against the Warehouse or SQL endpoint, all accumulating as 24-hour background usage.
  • Too many small files. Every downstream reader, whether Spark, SQL or Direct Lake, pays more to read a table split into thousands of tiny files.
  • Poorly timed overlapping schedules. Every job set to start at the top of the hour or at 02:00.
  • Refresh concurrency. Many semantic model refreshes running at once, or refreshes scheduled far more often than the data changes.
  • DEV/TEST and PROD on the same capacity. A developer’s exploratory notebook or a load test competing with production reporting.
  • Retry storms. A failing source makes pipelines retry, each retry restarts heavy work, and a small outage turns into hours of wasted capacity.
  • Large semantic model operations. Full refreshes of large import models, or heavy models queried by many users at once.

Reading the Capacity Metrics app

The Microsoft Fabric Capacity Metrics app is the primary tool for capacity investigation. Capacity admins install it from AppSource and point it at their capacities. Install it before the first incident: you want history from before the problem.

Three things to know before reading it:

  • Data arrives with a delay, typically 10 to 15 minutes. New workspaces and items appear after the app’s nightly refresh, or after a manual refresh of its semantic model.
  • The Compute page covers the last 14 days. Anything older has to be exported or captured elsewhere.
  • The app is updated often. At the time of writing, version 3.0 ships the established default report and a redesigned preview report side by side. Page names below refer to the default report. Expect some layout changes over time; the investigation logic stays the same.

What to look at, in order:

  1. The Health page for a quick overview of which capacities consume the most or are being throttled.
  2. The Compute page utilization chart for the shape of consumption over time, split between interactive and background, against the capacity’s limit. Spikes above the line are overages, not necessarily throttling.
  3. The throttling charts on the Compute page for whether smoothed usage crossed the interactive delay, interactive rejection or background rejection limits. This is where you confirm whether the capacity was actually throttling during the user-reported window.
  4. The overages view for carryforward, cumulative overage and burndown. It shows how long the capacity took, or will take, to recover.
  5. The System events table for state changes: throttling stages, surge protection activating, pause and resume.
  6. The matrix of items and operations for which workspaces, items and operation types consumed the most CU seconds over the period. This is where top consumers become visible.
  7. The Timepoint drill-through for a single 30-second timepoint. It lists the interactive and background operations contributing to it, including smoothed background operations that started hours earlier, with item, user, duration and CU share.

Reading the timepoint view correctly is the core skill. The background operations listed there are not “what was running at that moment”. They are everything whose smoothed cost lands in that timepoint. Sort by contribution, not by start time.

The app itself does not send alerts. For notifications on capacity state, use capacity overview events in the Real-Time hub, or capacity notifications in the admin settings.

Symptoms and where to look

Symptom Likely cause What to check
Refreshes suddenly slower, or failing Background load accumulated during the day, too many refreshes at once, or the capacity reached background rejection Throttling charts (background rejection), System events, refresh schedules overlapping in the item matrix
Notebooks start later, or fail to start Spark cores in use (pipeline jobs queue; interactive runs fail with TooManyRequestsForCapacity), or the capacity is throttled Spark monitoring and queue; whether System events show throttling at that time
SQL queries become inconsistent Concurrent heavy queries, or a high background baseline from earlier Warehouse and Spark work, or the query itself Timepoint drill-through for background contributors; query insights for the slow statements
Users see intermittent report delays Interactive delay stage: smoothed usage above the 10-minute limit Throttling charts (interactive delay); which background operations dominate the timepoints
Users get “capacity exceeded” errors Interactive or background rejection stage System events; rejected operations in the timepoint drill-through
Capacity looks quiet after an incident, but problems continue Carryforward still burning down from earlier overuse Overages view; minutes to burndown
One team’s work slows everyone A single workspace or item dominating consumption Matrix of items and operations, sorted by CU seconds

A practical investigation workflow

When someone reports that “Fabric is slow”, resist resizing first. Work through the evidence:

  1. 1Identify the impact windowWhen did users notice, and what exactly was slow or rejected?
  2. 2Confirm capacity pressureThrottling charts and system events, not the utilization line alone
  3. 3Find top-consuming operationsTimepoint drill-through, sorted by CU contribution
  4. 4Map to workspace and jobItem, operation, schedule, owner
  5. 5Check concurrencyWhat overlapped, and what was smoothed in from earlier?
  6. 6Was it expected?Compare with the normal baseline for that job
  7. 7Decide the remedy
    • Optimize
    • Reschedule
    • Isolate
    • Resize
    • Stop unnecessary work
Investigating a capacity incident. Evidence first, remedy last. Resizing is one of five outcomes, not the default.
  1. Identify the impact window. Get the time and the symptom: slow report, rejected query, notebook that did not start, refresh that failed. Account for the app’s data delay.
  2. Confirm whether capacity pressure existed. Check the throttling charts and system events for that window. If there was no throttling, the problem is probably the item itself: a slow query, a heavy model, a cold Spark session. Microsoft’s own guidance notes that slow performance is more often a design issue than throttling.
  3. Identify the top-consuming operations. Drill into the worst timepoints and sort operations by their contribution.
  4. Map them back to a workspace, workload and job. An item name is not enough; find the pipeline, schedule or person behind it. The pipeline and notebook monitoring guide covers linking pipeline runs to notebook runs.
  5. Check concurrency. What overlapped in the window, and which background work from the previous hours was still being smoothed into it?
  6. Check whether the consumption was expected. A job that normally costs X and suddenly costs 5X points to a change: more data, a code deployment, a runtime upgrade, a retry loop, a full reload where an incremental one used to run.
  7. Decide the remedy:
    • Optimize when one item dominates and is doing unnecessary work.
    • Reschedule when the load is reasonable but overlaps with interactive peaks or other jobs.
    • Isolate when workloads with different priorities keep interfering.
    • Resize when the load is legitimate, already efficient and consistently above the budget.
    • Pause or stop unnecessary work: idle sessions, abandoned schedules, refreshes nobody uses.

Capacity isolation

Because throttling is per capacity, separate capacities are the strongest isolation Fabric offers. Use them where interference is costly:

  • PROD separate from DEV/TEST. The most common and most justified split. Exploratory notebooks and load tests should not be able to throttle production reporting.
  • Interactive BI separate from heavy engineering, when large background workloads repeatedly push report users into delays.
  • Critical reporting that must stay responsive regardless of what engineering runs.
  • High-volume batch workloads with a different schedule and cost owner.
  • Tenants or customers, in a multi-tenant platform where one customer’s load must not degrade another’s, or where cost has to be attributed per customer.

Isolation has costs: more capacities to size, monitor and pay for, and less ability for quiet workloads to lend headroom to busy ones. Every workspace does not need its own capacity. Start with the splits that separate genuinely different priorities, and add more only when the Metrics app shows interference you cannot fix by scheduling or optimization.

Workspace placement

Capacity is assigned per workspace, so workspace design is capacity design. Putting a heavy ingestion notebook and an executive dashboard in the same workspace guarantees they share a capacity. Splitting them into separate workspaces makes it possible to place them on different capacities later, with a reassignment rather than a redesign.

Practical consequences:

  • Separate workspaces by environment (DEV, TEST, PROD) and, at scale, by workload type (ingestion and engineering vs serving and reporting). Create Your First Microsoft Fabric Workspace covers environment separation from day one.
  • Think about which capacity each workspace belongs to when you design the platform, not after the first incident. Designing a Scalable Microsoft Fabric Architecture treats workload boundaries and capacity together.
  • Capacity assignment is part of your deployment design. A CI/CD process that promotes from DEV to PROD workspaces works best when those workspaces already sit on the capacities you intend.
  • Keep capacity ownership explicit: who can assign workspaces, who watches the Metrics app, who decides on resizing. The governance guide covers the platform team’s role.

Pausing and resizing

F SKUs can be resized and paused in Azure. Both are operational levers, and both are easy to misuse.

Resizing changes the budget for every timepoint from then on.

  • It helps when the load is legitimate, already reasonably efficient and consistently above the budget, or when a known peak (month-end, a migration) needs temporary headroom.
  • Temporarily scaling up also burns down carryforward faster during an incident, because each timepoint has more spare capacity.
  • It only masks the problem when one inefficient job, a retry storm or a schedule collision is the cause. The waste continues at the larger size, and the next growth step brings the same incident back.
  • Resizing across the boundary between F256 and below and F512 and above, in either direction, can briefly interrupt the capacity, and Fabric can cancel in-flight operations and running jobs during the transition. Microsoft recommends doing these resizes in a maintenance window or a period of low activity, then rerunning any canceled jobs (Microsoft Learn: scale your capacity). This applies to resizes that cross that boundary, not to every resize.

Pausing stops the capacity.

  • Content assigned to a paused capacity is unavailable. Pause only capacities nobody is using, such as a development capacity overnight.
  • When you pause, the remaining smoothed usage and cumulative overages are summed and billed at once. Pausing does not make already-consumed compute free.
  • Pausing ends throttling immediately: a resumed capacity starts with no future usage committed. That makes pause and resume a blunt emergency lever for a throttled capacity that is not serving anything critical, at the cost of making its content unavailable while paused.
  • Schedules can pause and resume capacities through Azure automation or the Fabric REST APIs. Make sure no pipeline is scheduled to run while its capacity is paused.

Capacity sizing

There is no reliable formula from rows, gigabytes or user counts to a SKU. Two platforms with the same data volume can need very different capacities, because consumption depends on what the workloads do, not on how much data exists:

  • Workload type: Spark, SQL, refreshes and interactive BI consume very differently.
  • Concurrency: the same jobs run sequentially or all at once.
  • Transformation complexity: a filter-and-append versus wide joins and window functions.
  • Spark session shape: pool size, node size, session reuse.
  • Refresh frequency: hourly versus daily.
  • SQL patterns: targeted queries versus wide scans.
  • Interactive users: how many, how often, on how heavy a model.
  • Background baseline: everything smoothed across the day.
  • Peak overlap: whether the heaviest work coincides with the busiest interactive hours.

A practical approach:

  1. Start with an expected workload profile. List the main jobs, their schedules, the semantic models and the interactive audience. Microsoft’s Fabric SKU Estimator and capacity planning guidance can give a starting point; treat it as a hypothesis, not an answer. Building that profile is part of platform design, before any capacity exists: see capacity and performance architecture in Designing a Production Data Platform.
  2. Measure. Run the real workloads, or a representative slice, on a capacity and read the Metrics app. Trial capacities and small development capacities are good for this.
  3. Observe the peak windows. Size for the worst realistic overlap, not the daily average. Look at the throttling charts during those windows, not just utilization.
  4. Optimize. Remove the waste you found: full reloads, oversized sessions, colliding schedules, unnecessary refreshes. This step often changes the answer by a whole SKU.
  5. Resize only with evidence. Scale when the throttling charts show sustained pressure from workloads you have already made efficient, and re-measure after each change.

Dealing with this during an incident? Follow the Fabric Capacity Saturation Runbook for what to check, in what order.

Is your Fabric capacity actually too small? The Fabric Capacity Planner turns the numbers you read in the Metrics app (typical and peak utilization, throttling evidence, workload mix) into an engineering read: health, headroom, what the same workload would look like on a larger or smaller SKU, and what to inspect before resizing. For this process applied to a real ingestion workload, see How I Diagnosed a Microsoft Fabric Capacity Saturation Problem.

Production recommendations

  • Stagger heavy jobs. Spread schedules instead of starting everything at the top of the hour, and keep the heaviest background work away from interactive peaks where possible.
  • Use incremental processing for large tables, so background load scales with change rather than with total size.
  • Bound retries. Limit retry counts and add backoff, so a source outage does not become a capacity incident.
  • Isolate noisy workloads that repeatedly interfere with critical ones, starting with DEV/TEST away from PROD.
  • Monitor trends, not single spikes. A spike that smoothing absorbs is normal. A background baseline that rises week after week is the real warning.
  • Make workloads identifiable. Clear item names, consistent workspace conventions and pipeline-to-notebook correlation make the Metrics app readable. A top consumer named Notebook 7 slows every investigation.
  • Review capacity after deployments. Compare a job’s consumption before and after a release. Most unexpected increases trace back to a change.
  • Validate after runtime changes. A new Spark runtime can change execution behavior and consumption. The runtime comparison covers what to test before upgrading.
  • Close idle sessions. Stop interactive Spark sessions when you are done, and review session startup choices such as live pools, which keep compute warm on purpose and at a cost.

Common myths

  • “More data always means more CU usage.” Consumption follows the work done, not the data stored. An incremental load over a huge table can cost less than a full reload of a small one.
  • “If nothing is running now, the capacity is fine.” Smoothed usage from earlier work can keep a capacity throttled after everything has finished.
  • “A bigger SKU fixes bad notebooks.” It postpones the incident. The inefficient job still burns more than it should, at a higher price.
  • “Every workspace needs its own capacity.” Isolate by priority and interference, not by default.
  • “Fabric capacity is just VM sizing.” It is a shared budget with smoothing, per-workload rates and staged throttling. Reasoning about it like a single server leads to the wrong fixes.
  • “Over 100% utilization means we are throttled.” Overage protection absorbs short surges. Check the throttling charts.

Production checklist

  • Capacity Metrics app installed and reviewed regularly, not only during incidents.
  • Top consumers identified by workspace, item and operation, with an owner for each.
  • Overlap understood: which schedules and interactive peaks coincide.
  • DEV/TEST isolation evaluated against production workloads.
  • Incremental processing used where full reloads dominate background load.
  • Notebook concurrency and session sizing reviewed, including idle sessions and session sharing.
  • SQL and query performance reviewed for the heaviest Warehouse, SQL endpoint and semantic model consumers.
  • Retries checked: bounded, with backoff.
  • Capacity trend monitored, with alerts on capacity state through capacity events or notifications.
  • Resizing justified with evidence from throttling charts after optimization, and re-measured afterwards.

What you learned

  • A Fabric capacity is a shared budget of Capacity Units, assigned per workspace and spent by every workload at its own rate. It is not a server.
  • Operations are interactive or background. Interactive usage is smoothed over minutes, background over 24 hours, and most Spark and Warehouse work counts as background.
  • Smoothing lets operations burst, but it also moves their impact into the future, so the cause of throttling has often finished before users notice.
  • Throttling escalates from interactive delays to interactive rejection to background rejection, based on how much future capacity is already committed. Recovery means burning down carryforward, not waiting for a quiet moment.
  • The Capacity Metrics app’s throttling charts and timepoint drill-through are where investigations are won.
  • Optimize, reschedule and isolate before you resize, and size from measured workload profiles, not from data volume.

Étiquettes

  • Microsoft Fabric
  • Capacité
  • Performance
  • Supervision
  • Dépannage