Microsoft Fabric
How I Diagnosed a Microsoft Fabric Capacity Saturation Problem
A sanitized production case study: a morning file-ingestion burst pushed a shared Fabric capacity well past 100%. How I separated capacity size from concurrency, per-file overhead and expensive workloads before deciding whether to scale.
On this page
Most of the day, the capacity looked unremarkable. Then the morning ingestion window started.
Files arrived over SFTP, roughly 500 to 600 of them on a busy morning, and each arrival set work in motion: validation, conversion and mapping, merge and load, calculations. Pipelines and notebooks overlapped on the same Fabric capacity, and the utilization chart climbed well past 100%. On some mornings it went past 200%.
The obvious conclusion was that the capacity was too small. It was also the conclusion I least wanted to reach first, because if it was wrong, a larger SKU would cost more every month and leave the real problem in place.
This is how I investigated it. The workload is described generically and the numbers are approximate on purpose. Throughout, I separate three kinds of statement: what Microsoft documents about how Fabric capacity works, what I observed in this workload, and what I recommend, which is my engineering judgement. If you need the concepts from scratch first, read Microsoft Fabric Capacity Explained. This article assumes them and focuses on the investigation.
The symptom
What I actually had at the start was narrow:
- A concentrated morning window. Most of the ingestion arrived in a few hours, not spread across the day.
- Hundreds of files. Roughly 500 to 600 on a busy day, mostly small, each one a unit of downstream work.
- Overlapping activity. File arrivals triggered pipeline runs, and pipeline runs started notebooks. Several stages for different files ran at the same time.
- One shared capacity. Ingestion pipelines, notebooks and the later calculation steps all drew on the same CU budget.
- Utilization far above 100% in the busy window, sometimes above 200%, then falling back as the backlog cleared.
- A smaller development capacity showed the same pattern even more sharply. The same kind of workload produced higher percentages and more visible saturation there.
What I did not have at the start was any evidence about cause. A utilization chart tells you that consumption was high relative to the SKU. It does not tell you whether that consumption was necessary, whether it was concentrated by scheduling, or whether it caused anything users would notice.
Why 200% did not automatically mean “double the SKU”
The tempting arithmetic is: 200% of the current SKU, so buy twice the SKU. Fabric’s capacity model is designed so that this arithmetic is usually wrong. These are documented platform behaviours (Microsoft Learn: capacity throttling and smoothing):
- Bursting. Operations can temporarily use more compute than the SKU provides, so jobs finish quickly instead of waiting for capacity.
- Smoothing. The CU cost of an operation is spread over future 30-second timepoints. Background operations (pipelines, Spark notebooks, almost all Warehouse work) are smoothed over 24 hours. Interactive operations are smoothed over 5 to 64 minutes, depending on their size.
- Carryforward and burndown. When smoothed usage exceeds the SKU in a timepoint, the excess is carried forward. Later timepoints with spare capacity pay it back.
- Throttling stages. Throttling depends on how much future capacity has already been consumed. Up to 10 minutes is overage protection, with no throttling. From 10 to 60 minutes, new interactive operations are delayed by 20 seconds. From 60 minutes to 24 hours, new interactive operations are rejected. Beyond 24 hours, background operations are rejected as well. Operations already running are allowed to finish.
Microsoft’s own documentation for the Capacity Metrics app states it plainly: utilization above 100% doesn’t always mean the capacity is throttled, and utilization below 100% doesn’t guarantee that it isn’t (Microsoft Learn: Capacity Metrics app compute page, preview).
So the working rule I used was this:
Capacity above 100% is an investigation signal, not proof that the SKU is too small.
There is a second reason a big percentage needs care, and it changed how I read the charts. A spike that climbs sharply and drops once the backlog clears does not look like smoothed background usage. Smoothed background usage persists for up to 24 hours after the work ran. A sharp rise and fall looks much more like consumption plotted when operations reported it. Both views are legitimate, but only the smoothed view is what throttling evaluates. Before interpreting “200%”, I had to establish which view the number came from.
Seeing similar peaks? Run the workload through the Fabric Capacity Planner before assuming you need a larger SKU. It turns typical and peak utilization, throttling evidence and the workload pattern into a headroom and next-step assessment.
What the workload looked like
The pipeline itself was ordinary. Every stage made sense in isolation:
- 1SFTPIncoming filesRoughly 500–600 files on a busy morning, mostly small
- file arrival2Discovery and ingestionDetects new files and starts the ingestion pipeline
- 3ValidationValidation notebook checks structure and content
- 4Conversion and mappingMapping notebook converts each file to the target shape
- 5Merge and loadMerges the converted rows into the production tables
- 6Calculation stageRecomputes values that depend on the newly loaded data
- 7Summary tablesSummary stage refreshes the reporting tables
The part that mattered for capacity was not any single stage. It was the shape of the work: many files, each fanning into several steps, all landing on one shared budget at roughly the same time.
- Run for file Avalidate → map → load
- Run for file Bvalidate → map → load
- Run for file Cvalidate → map → load
- Hundreds morearriving within the same window
- Shared Fabric capacityOne CU budget for ingestion, notebooks and calculations
Establish the timeline
Before touching any optimization, I wrote down what happened when, in plain words. A representative morning looked like this:
| Window | Observation |
|---|---|
| Before ingestion | Capacity relatively quiet; background baseline only |
| File arrival starts | Pipeline activity increases as files are discovered |
| Concurrent processing | Notebook and pipeline CU rises; several stages overlap |
| Peak window | Utilization above 100%, on some days above 200% |
| Backlog clears | Utilization begins falling as fewer runs start |
| Later | Capacity returns toward its baseline |
The timeline was useful because it made one thing obvious: the peak followed the arrival pattern. It was not a random spike, it was not the whole day, and it was predictable. That already pointed away from “the daily workload is too big” and toward “too much of it starts at once”. The timeline alone could not settle that, though.
What I checked in Capacity Metrics
The Microsoft Fabric Capacity Metrics app is where capacity questions get answered or ruled out. The redesigned (preview) compute page has three views, and each answers a different question:
| View | What it shows | What I used it for |
|---|---|---|
| Smoothed: Last 24 Hours | Smoothed usage at fine granularity | Did the morning window actually push the capacity into a throttling state? |
| Smoothed: Last 14 Days | The same, over two weeks | Is this a daily pattern, and does it recover every day? |
| Unsmoothed: Last 14 Days | Consumption when operations reported it, without smoothing | Which item kinds and items consumed the most, and when they ran |
In the smoothed views, I looked at:
- CU(s) over time. Average CU-seconds per second against the SKU limit. It stays comparable when the SKU changes, which matters when you compare a development capacity with production.
- CU % over time. The same consumption as a percentage of the SKU. Halve the SKU and this percentage doubles, even though the work is identical.
- Throttling. Separate trends for interactive delay, interactive rejection and background rejection. This, not the utilization chart, tells you whether the capacity was being throttled.
- Overage (Carryforward). Overage added, burned down and cumulative. The question here is whether carryforward clears before the next morning’s window or keeps building.
- System events. State changes such as entering and leaving interactive delay, with times.
- The capacity health heat map and the impacted items. These show which items attempted to run and were delayed or rejected.
From a peak timepoint, the drill-through ranks interactive and background operations by CU, with columns for total CU-seconds, the share landing in that timepoint, duration, and smoothing start and end (Microsoft Learn: timepoint page). Its burndown table includes a minutes to burndown estimate.
The unsmoothed view earned its place. A background operation that reports at 08:00 shows all of its consumption at 08:00 there, while the smoothed views spread it across the next 24 hours. That makes the unsmoothed view the one to use when you want to line consumption up with what was running at that time. It is not the view that tells you whether the capacity throttled, so I kept the two questions separate:
- When did usage hurt capacity health? Smoothed views and throttling charts.
- What consumed it, and when did it run? Unsmoothed view and item drill-down.
One more consequence of smoothing matters for a background-heavy workload like this one. A large morning burst of background work does not disappear when the jobs finish. Its smoothed contribution stays on the capacity for the next 24 hours, and that baseline also counts toward the 10-minute and 60-minute interactive limits. If anything interactive shares the capacity, such as reports or ad hoc queries, it can be delayed by background work that finished hours earlier.
Four different problems can look like “capacity”
This is the part of the investigation I would reuse on any capacity problem. A high utilization chart is a symptom that at least four different problems share. Each one has a different fix, and the fixes are not interchangeable.
Problem A: the workload is genuinely too large
Symptoms: consumption is high across the whole day, not just in one window. Throttling charts cross their limits regularly. Carryforward does not burn down between busy periods. The growth behind it is permanent: more sources, more files, more users.
Response: optimize where it is reasonable, then test the next SKU and measure. Scaling is the correct answer here, not a failure.
Problem B: too much concurrency
Symptoms: the total daily workload fits the capacity, but too much of it starts at once. Peaks are sharp, predictable and tied to a schedule or an arrival pattern. The 14-day view shows the same shape every morning, with quiet capacity around it.
Response: stagger work, reduce unnecessary parallelism, and change orchestration so that independent work does not all start in the same minutes. When one workload must never be affected by another, isolate it on its own capacity.
Problem C: one expensive workload dominates CU
Symptoms: one notebook, query or item accounts for a disproportionate share of CU in the drill-through, often with long durations or work repeated more often than needed.
Response: tune that workload first. Fixing one item is cheaper than buying capacity for everything.
Problem D: the architecture amplifies overhead
Symptoms: per-unit overhead is multiplied by the number of units. Hundreds of small files each get the full pipeline. Orchestration and notebook invocation repeat per file. Each step re-reads configuration or metadata. The useful work per run is small compared with the fixed work around it.
Response: batch or aggregate where it is safe, redesign orchestration so one run handles many files, reuse Spark sessions where it is supported, and remove avoidable startup work.
The morning ingestion window had the signature of B and D together: a predictable, arrival-driven peak and a per-file processing model. Whether C was also present, and whether A would remain once B and D were addressed, were questions the utilization chart could not answer. They needed item-level evidence. Real incidents are often a mix, and I did not treat this one as having a single root cause.
| A: too large | B: concurrency | C: expensive item | D: overhead | |
|---|---|---|---|---|
| Peak shape | Broad, all day | Sharp, scheduled | Follows one item | Scales with unit count |
| Where it shows | Smoothed 14-day view | 14-day pattern, timeline | Timepoint drill-through | Operation counts, execution log |
| First response | Measure, then test next SKU | Stagger, limit parallelism | Tune that item | Batch, reuse, redesign |
Why small files matter
Five hundred small files are not the same workload as one file five hundred times the size, even if the total bytes are similar. The data volume is the same; the amount of work around the data is not. Per-file processing multiplies:
- orchestration: each file can mean another pipeline run with its own activities;
- task setup: connections, configuration reads and lookups repeated per run;
- notebook invocation: a notebook activity per file and stage, each needing a Spark session;
- metadata operations: listing, moving, archiving and writing small outputs;
- concurrent activity: hundreds of independent runs that all become eligible within the same window.
Some of this is directly metered. Microsoft documents pipeline orchestration at 0.0056 CU-hours for each non-copy activity run, with Copy activity metered separately by duration (Microsoft Learn: pricing for pipelines). As an illustration, not a measurement from this workload: 550 files × 6 non-copy activities per file is 3,300 activity runs. That is about 18 CU-hours of orchestration alone, before a single notebook or copy runs. Change the design so one run handles a batch of files and that number falls in proportion.
That example is not a claim that orchestration caused the peaks. In most workloads the notebooks and data movement dominate. The point is structural: in a per-file design, every fixed cost is multiplied by the file count, so even small fixed costs deserve a look.
Notebook startup and concurrency
Notebook startup is where my interpretation changed the most, because “startup overhead” means two different things.
Startup as latency. Microsoft documents that Spark billing applies to active session runtime. Cluster acquisition and Spark context initialization are not billed (Microsoft Learn: Spark billing and utilization). Waiting for a session is therefore mostly a latency problem. It makes a short pipeline slow end to end, and the startup article covers diagnosing it. On its own, though, it is not where the CUs go.
Startup as capacity. What is billed is everything an active session does and holds:
- Per-session fixed work. Installing libraries inline, importing heavy modules, reading configuration, initial lookups. Repeat that hundreds of times and it becomes real consumption.
- Minimum session size. A notebook that processes one small file still holds a driver and executors for its duration.
- Idle sessions. The default session expiration is 20 minutes. A session that finished its work but stays open still counts as active.
- Spark concurrency limits. One CU maps to two Spark VCores, and each SKU has documented base and burst VCore limits (Microsoft Learn: Spark concurrency and queueing). Many concurrent sessions can hit those limits. Pipeline-triggered jobs then queue, and some submissions fail with HTTP 430. Concurrency becomes visible as waiting time, not just as utilization.
The practical levers are the ones covered in high-concurrency sessions and session tags. Compatible notebooks can share a session instead of each acquiring one, the per-session preamble can be made smaller, and dependencies can move into an Environment instead of inline installs. I would not overstate the effect. Session reuse removes repeated fixed work and acquisition wait; it does not make a heavy transformation cheaper. For a workload with hundreds of short notebook runs, though, repeated fixed work is exactly what adds up.
Execution logging changed the investigation
Capacity Metrics knows items and operations. It does not know business context: which file a notebook run processed, which stage it was in, how many rows it touched, or whether it was a retry. Without that context, the drill-through tells you “the mapping notebook used a lot of CU at 08:40”. It cannot tell you whether that was one large file, forty small ones, or the same file retried three times.
An execution log supplies the missing half. For each pipeline and notebook execution, the useful fields were:
| Field | Why it mattered for capacity |
|---|---|
execution_id, parent execution |
Ties a notebook run to the pipeline run that started it |
| Pipeline or notebook name, stage | Validation, mapping, merge/load, calculation, summary |
start_time, end_time, duration |
Lines runs up against Capacity Metrics timepoints |
Status, retry_count, failure reason |
Separates repeated work from new work |
| File count, rows processed | Distinguishes many small runs from a few large ones |
| Workload identifier | Which source or feed the run belonged to |
With that table, the question changes from “why is the capacity at 200%?” to “what was actually running at 08:40, how many of it, and for which files?”. A capacity spike becomes a list of executions you can count, group by stage and compare across days. The log is also where concurrency becomes measurable. You can count how many runs of each stage overlapped in each minute, and that count is the evidence behind Problem B.
Monitoring Fabric pipelines and notebooks covers how to build alerts and baselines on this, and debugging Fabric pipelines and notebooks covers using the same correlation when a run fails rather than runs hot.
What I would test before scaling
This is an experiment plan, in order. Each step either removes waste or produces evidence for the next one.
- Identify the dominant CU consumers in the peak window: item kind, item and operation, from the drill-through and the unsmoothed view.
- Correlate them with executions: join the busy timepoints to the execution log by time, stage and file count.
- Reduce unnecessary concurrency: cap how many per-file runs can start at once, so the work queues in orchestration rather than landing on the capacity all at once.
- Stagger noncritical work: move calculation and summary stages that do not need to follow each file immediately to after the arrival window.
- Reduce repeated notebook and session startup: share compatible sessions, remove inline installs, and trim per-run preambles.
- Batch small-file processing where it is safe: let one run handle a group of files when ordering and failure isolation allow it.
- Tune expensive transformations: the specific items from step 1, starting with the largest.
- Re-measure the same window on comparable mornings.
- Compare throttling and burndown, not just peak utilization: did the throttling trends drop, and does carryforward now clear before the next window?
- Then test the next SKU, if the evidence still says the capacity needs more headroom.
The point is not “never scale”. The point is to make scaling an engineering decision with a measured before and after, rather than a reaction to a chart.
What scaling actually changes
Each step up the F SKU ladder doubles base capacity: F16 → F32 is 2× the CUs, and F32 → F64 is 2× again. The arithmetic is easy to state:
| Same workload on… | Base CUs | Normalized utilization |
|---|---|---|
| F32 (observed) | 32 | 160% |
| F64 | 64 | ≈ 80% |
| F128 | 128 | ≈ 40% |
That is mathematical normalization only: the same CU consumption divided by a larger budget. What it does not tell you:
- Runtime does not necessarily halve. Many jobs are not limited by the capacity budget at all.
- Concurrency behaviour changes. A larger SKU has higher Spark VCore limits, so more runs can start at once. That can move a peak rather than flatten it.
- Bottlenecks can remain. A slow source, a serialized step or a skewed join is still there on a larger SKU.
- Inefficient workloads remain inefficient. They now cost twice as much to run.
- Scaling can hide architecture problems until growth catches up, and then they arrive at twice the price.
Microsoft also documents operational details worth knowing before resizing. Resizing across the F256/F512 boundary can briefly interrupt the capacity and cancel running jobs. Scaling below a reservation does not reduce the bill. A temporary scale-up does burn down carryforward faster (Microsoft Learn: scale capacity). The Fabric Capacity Planner runs the same normalization for any pair of SKUs, in both directions, and flags those side effects.
When scaling is absolutely reasonable
I want to be balanced about this. Optimization is not a virtue in itself, and endlessly tuning a workload that genuinely needs more compute is its own waste. Scaling is the right call when:
- the workload has been reasonably optimized, and the remaining consumption is real work;
- peaks are frequent and sustained, not one predictable window that scheduling could spread;
- throttling is confirmed in the throttling charts and system events, not inferred from utilization;
- carryforward cannot burn down between workload windows;
- user-facing activity is affected: delayed or rejected interactive operations;
- growth makes the demand permanent: more sources, more files, more consumers;
- the workload needs more headroom than optimization can realistically recover in the time available.
Sometimes the correct engineering answer is simply more capacity, and you should be able to say so with the same evidence you would use to argue against it.
Development vs production capacity
The smaller development capacity turned out to be one of the most useful tools in this investigation. A smaller SKU makes the same work show up as a larger percentage, and it reaches Spark concurrency limits sooner. That makes it good at exposing:
- concurrency sensitivity: how much the peak depends on how much starts at once;
- expensive notebooks: the items that dominate when the budget is small;
- inefficient pipeline patterns: per-file fan-out and repeated activities;
- startup overhead: fixed per-run work that disappears into the noise on a large SKU.
What it does not do is predict production linearly. An F16 result does not tell you what F64 will do. The base budget is four times larger, the Spark VCore limits are higher, so more runs start concurrently, and production data volumes and arrival patterns differ. Compare CU(s) over time rather than CU %, so SKU size does not distort the comparison. Treat development results as a way to find problems, not as a sizing forecast.
Diagnostic decision tree
When a capacity chart goes above 100%, these are the questions I now ask, in order:
- 1High CU utilizationWhich view? Smoothed for capacity health, unsmoothed for what ran when.
- 2Is throttling occurring?No: keep monitoring and optimize what is wasteful. Yes: continue.
- 3Temporary or sustained?Temporary and predictable: suspect concurrency. Sustained all day: suspect size.
- 4Which workload dominates CU?Timepoint drill-through and unsmoothed view, joined to the execution log
- 5One operation or many?One expensive item: tune it. Many small runs together: concurrency or overhead.
- 6Does carryforward burn down?Yes, before the next window: reschedule or smooth the peak. No: capacity pressure is real.
- 7Decide and re-measureOptimize, reschedule, isolate, or test the next SKU
- Evidence
- one item dominatesOptimize
- predictable peakReschedule
- critical work affectedIsolate
- sustained throttlingTest next SKU
Try the Fabric Capacity Planner
I built the Fabric Capacity Planner around this investigation. You enter what the Capacity Metrics app shows: the current SKU, typical and peak utilization, how long and how often the peak lasts, which throttling stage you have seen, the workload mix and pattern. It returns a health assessment, the evidence behind it, what to inspect next, and the next SKU worth testing, with a normalized comparison across neighbouring SKUs.
It is an engineering planning tool, not an official Microsoft sizing recommendation. Validate anything it suggests with the Capacity Metrics app and Microsoft’s official Fabric SKU Estimator before resizing or purchasing capacity.
What I learned
- A peak above 100% is not a sizing decision by itself. Bursting and smoothing exist to absorb peaks. Throttling and carryforward are the signals that matter.
- Know which view you are reading. Smoothed views show capacity health; the unsmoothed view shows what ran when. Mixing them up produces confident, wrong conclusions.
- Concurrency can matter as much as total volume. A workload that fits the day can still overwhelm the morning.
- Small-file architectures amplify fixed costs. Orchestration, setup and session work are multiplied by the file count.
- Notebook startup matters when multiplied. Acquisition time mostly costs latency; per-session work and idle sessions cost capacity.
- Capacity Metrics and execution logging are far more useful together. One says how much was consumed; the other says what it was.
- Scaling is valid when the evidence says the capacity genuinely needs more headroom. Make it a measured decision, not a reflex, in either direction.
To run this investigation as an ordered procedure during a live incident, use the Fabric Capacity Saturation Runbook. For the broader workflow around this, from baselines to skew and Delta layout, see Troubleshooting Microsoft Fabric Performance in Production. For keeping workloads apart by design, see Designing a Scalable Microsoft Fabric Architecture and Pipelines vs Notebooks vs Dataflow Gen2 vs Copy Job.
Was this helpful?
What could be better?
Thanks — that helps me improve Javi Builds.
Continue learning
- Cheat sheetFabric Session TagsUse Microsoft Fabric session tags to reuse compatible Spark sessions across notebook activities, reduce startup overhead, and avoid unnecessary session fragmentation.Open cheat sheet
- RoadmapFabric in ProductionA sanitized production case study: a morning file-ingestion burst pushed a shared Fabric capacity well past 100%. How I separated capacity size from concurrency, per-file overhead and expensive workloads before deciding whether to scale.View roadmap
What should I build next?
I'm building Javi Builds around practical problems data engineers actually face. Tell me what you'd like to see next.
Stay in the loop
Get the Javi Builds updates you actually care about.
Check your inbox
I sent you a confirmation link. Your subscription will be active after you confirm it.