Excel Spill Error: How to Fix #SPILL! Fast in 5 Ways

You’ve just typed a formula that should have been perfect. =UNIQUE(A2:A100) is simple, logical, and exactly what every Excel tutorial told you to write. Excel, however, answers with a cryptic red #SPILL! — and your clean list is nowhere to be found.

Before I learned to read what it was telling me, the excel spill error made me groan every single time. But after years of building financial models and auditing messy workbooks for clients, I’ve come to see it differently. The #SPILL! error is not a bug. It’s not a punishment for writing bad formulas. It’s a guardrail — and a remarkably specific one.

Dynamic arrays changed the way modern Excel calculates results. Instead of returning one value per formula, Excel now lets a single formula return many results at once — but only if the target cells are empty and available. When they aren’t, Excel doesn’t silently overwrite your data. It stops and points at the problem. That protection alone is worth understanding.

This guide walks you through the whole journey: what an excel spill range actually is, why #SPILL! errors appear, how to diagnose the cause in seconds, and — more importantly — how to use dynamic arrays like FILTER, UNIQUE, and SORT with confidence.

---

What Is Excel Spill? Understanding Spill Range and Dynamic Arrays

When people ask me “what is Excel spill?” in training sessions, I usually start with a physical image. Imagine pouring water into a row of empty glasses. If a glass is already full, the water has nowhere to go, so it backs up and makes a mess. Excel spill works the same way: a formula produces a set of results, and that set needs a contiguous block of empty cells to land in.

That block of cells is called the spill range. In the worksheet, Excel marks it with a blue border so you can see exactly which cells the formula “owns.” Here’s the simplest possible example: type =SEQUENCE(5) in cell B2 and press Enter. Excel immediately fills B2:B6 with the numbers 1 through 5.

[Visual: screenshot of a worksheet showing =SEQUENCE(5) in B2 and the blue border surrounding B2:B6.]

One formula. Five cells. That’s a dynamic array in action. The formula was typed only in B2 — if you click any of the cells B3:B6, you’ll see a gray ghost formula in the formula bar that you can’t edit directly. Those cells belong to the spill range.

How Spill Works, Not Just What It Means

If you’ve used Excel for more than a decade, you’ll remember the old rules. In legacy Excel versions, a formula like =A2:A10*B2:B10 would normally evaluate to a single value using something called implicit intersection — it would grab the value from the same row as the formula and ignore the rest of the range. To get multiple results, you had to select the output range, type the formula, and press Ctrl+Shift+Enter to create a legacy array formula. Then you’d see curly braces {} appear around it in the formula bar.

Modern Excel replaced that entire workflow. Dynamic arrays were introduced to Microsoft 365 subscribers starting in 2020 [需核实 for exact rollout dates per channel], and then arrived in the perpetual-license releases Excel 2021 and Excel 2024. In these versions, formulas don’t need Ctrl+Shift+Enter anymore. You write the formula once, and it spills automatically.

The @ operator is the bridge between the two worlds. When you prefix a range with @, you’re explicitly asking Excel to apply implicit intersection again and return just one value. So =A2:A10 spills ten results, while =@A2:A10 returns only the value from the row where the formula sits.

One thing worth noting: if you ask a classically-trained Excel user to audit your workbook, they may assume you made a mistake when they see a blue border around cells they didn’t fill. You haven’t. That blue border is the signature of a healthy spill range.

Spillover vs #SPILL!: The Core Confusion That Derails Most Users

The word “spill” is also used for an entirely different Excel behavior, and that confuses people more than it should.

Spillover (or text overflow) happens when you type a long text string in cell A1 and it visually overflows into B1, C1, and beyond — as long as those adjacent cells are empty. This isn’t a formula behavior at all. It’s just display formatting. The text is still stored only in A1; B1 and C1 are completely empty. The moment you type anything into B1, the text in A1 stops displaying beyond the edge of A1.

#SPILL! is the complete opposite. It’s an error that appears when a dynamic array formula wants to expand into a range, but something is blocking it. The formula isn’t returning text that looks like it’s flowing into nearby cells. It’s trying to place actual values there, and Excel won’t let it.

A quick side-by-side makes the distinction memorable:

• Spillover: Typing “Quarterly Financial Report” in A1 with empty cells to the right → text appears to cross into B1/C1.
• #SPILL! error: Typing =SEQUENCE(5) in A1 when B1 already contains a number → Excel returns #SPILL! because its output needs B1 but B1 is occupied.

If you remember nothing else, remember this: spillover is cosmetic, and #SPILL! is structural. One is text doing what text does; the other is an array formula being told, “You can’t land there.”

---

Excel Spill Error Reasons: The #SPILL! Diagnostic Table

Over the years, I’ve probably diagnosed several hundred #SPILL! errors — in Excel training classes, in consulting engagements, and in my own models. The encouraging pattern is that the error almost never has more than a handful of causes. Once you know what they are, you can skip the guesswork entirely.

The #SPILL! Error-Cause-Fix Quick Reference Table

Here’s the diagnostic table I keep pinned to my own reference sheet. Bookmark it. You’ll need it the next time a perfectly reasonable formula refuses to cooperate.

Invisible Blockers: The Hidden Cause of Excel Spill Not Working

Here’s the scenario that confuses even experienced analysts: Excel says your spill range is blocked, you look at the cells, and they appear completely empty. No numbers. No text. No obvious reason for the error.

Invisible blockers are real, and they cause a disproportionate share of the “why is my excel spill not working?” questions I receive.

The usual suspects:

• Empty string formulas. A formula like =IF(B2="","",B2) in a cell produces what looks like a blank cell, but it actually contains a formula that evaluates to "". To Excel’s calculation engine, that cell is very much occupied.
• Phantom spaces. A single space character typed into a cell is invisible to the eye but visible to Excel. It blocks the spill range just as effectively as the number 10,000.
• Hidden formatting or objects. Transparent shapes, images with zero opacity, and comment indicators sitting over the spill range can all create obstructions that you can’t easily see.
• Custom cell formatting. Cells formatted with custom number formats that display as empty can still hold values, which makes them appear blank when they aren’t.

When Excel detects this situation, it draws a dotted border around the entire intended spill area and places an error icon next to your formula. Click the icon, and you’ll see Select Obstructing Cells — Excel will jump directly to whatever is blocking the range, visible or not. If nothing appears to be selected, check the Name Box to confirm which cell Excel flagged. You’ll often find something hiding there that wasn’t visible on screen.

One habit prevents a lot of these headaches: when you need to clear a spill range, use Home → Clear → Clear All, not just the Delete key. Clear All removes content, formatting, and any hidden quirks in one shot. Delete only removes content, which leaves formatting and empty-string residue in place.

---

How to Fix Excel Spill Error: Scenario-Based Solutions

Understanding the causes is half the battle. The other half is knowing the fastest fix for your specific situation. Let’s walk through the five scenarios I encounter most often in the field.

Fix 1: Excel Spill Range Blank or Blocked in a Normal Range

This is the highest-frequency cause. Your formula looks correct, the target area looks empty, but Excel insists there’s a problem.

Step 1: Click the formula cell. Look for the dashed blue outline. That outline shows exactly where Excel wants to spill. Any cell inside that outline that contains anything — a value, a formula, a space — will trigger the error.

Step 2: Click the error icon next to the #SPILL! text and choose Select Obstructing Cells. Excel will highlight the specific cells causing the problem.

Step 3: Clear the obstruction. Go to Home → Clear → Clear All to reset those cells completely. If the cells contain data you actually need, don’t delete it — move your formula somewhere else, or relocate the obstructing data.

Step 4: Re-enter the formula to force Excel’s calculation engine to re-evaluate the spill range. Often, simply pressing Enter after clearing the obstruction is enough.

[Visual: sequence of screenshots showing (a) the blue dashed border around a proposed spill range, (b) the error icon dropdown with “Select Obstructing Cells” highlighted, and (c) the same formula spilling successfully after the obstruction is cleared.]

In dozens of workbooks I’ve audited, this fix resolves about three-quarters of all spill errors. That’s why I always recommend starting here before you start changing your formulas — or, heaven forbid, rewriting an entire model.

Fix 2: #SPILL! Error in Excel Table (Including PivotTable Scenarios)

Excel Tables — the structured ranges you create with Ctrl+T — are one of the best features Excel has ever shipped. They auto-expand when you add data, they carry formatting down automatically, and they give you readable structured references like Table1[Amount].

They also refuse to play nice with dynamic arrays.

Here’s why: an Excel Table is itself dynamic. When you add a row, the table expands. When you add a column, it grows sideways. If you try to put a formula inside a table that also wants to dynamically expand — say, =SORT(Table1[Amount]) — Excel can’t decide which part owns the expansion. Microsoft’s official documentation on the topic is unambiguous: spilled array formulas are not supported inside Excel Tables [source: Microsoft Support — How to correct a #SPILL error].

Your options:

1. Convert the table to a range. Right-click anywhere in the table → Table → Convert to Range. You’ll lose some table conveniences, but your formatting usually survives intact, and the #SPILL! error typically clears immediately.
2. Place the dynamic array formula outside the table. This is my preferred approach. Keep the table for data entry, and park your FILTER/UNIQUE/SORT logic in a blank area beside or below it.
3. Use the @ operator when you only need the current row. This fix deserves special attention because it’s surprisingly under-documented.

The XLOOKUP-in-a-Table Case

Not every formula inside an Excel Table is trying to spill. Sometimes the #SPILL! error shows up when you didn’t intend an array at all.

Here’s an example from a finance team I worked with recently. They had a transactions table and wanted to map each account code to a category using XLOOKUP. The formula they wrote was:

=XLOOKUP([Account], AccountsMapping[Account Name], AccountsMapping[Overall Mapping])

Looks reasonable, right? Except XLOOKUP is capable of returning multiple results. When you feed it a whole column reference like [Account], Excel interprets that as “return a result for every row in the column” — a dynamic array. And since it’s inside a structured table, it cannot spill. Result: #SPILL!.

The fix is a single character:

=XLOOKUP([@Account], AccountsMapping[Account Name], AccountsMapping[Overall Mapping])

The @ before [Account] tells Excel, “Only look at the current row.” This is the implicit intersection operator, and it’s the difference between a formula that tries to flood the entire column and one that copies down neatly row by row.

If you work with PivotTables and get spill errors when referencing PivotTable fields with GETPIVOTDATA or legacy formulas, the usual culprit is that Excel’s PivotTable layout reserves cells for subtotals and labels that aren’t visible to you. In that case, move your PivotTable references into helper columns positioned well outside the PivotTable’s footprint, or use GETPIVOTDATA on a single cell rather than a range.

Fix 3: #SPILL! When Using UNIQUE or FILTER with Entire Columns

This might be the most common self-inflicted wound I see in modern Excel workbooks.

You want a list of unique customers, so you write something like:

=UNIQUE(A:A)

On paper, that means “list every unique value in column A.” What Excel hears is: “Calculate a result for up to 1,048,576 rows — the maximum rows in a worksheet — and spill that result somewhere.” When the calculated output would be enormous or would extend past the worksheet boundaries, Excel returns #SPILL! and displays the message “Spill range is too big.”

I once watched a data analyst spend an hour trying to “fix” this by clearing cells all over the sheet, when the real problem was the size of her request, not the layout of her worksheet.

The solution is to give your formula a clear, bounded reference:

=UNIQUE(A2:A10000)

Even better, convert your source data to an Excel Table and reference the table column:

=UNIQUE(Table1[Customer])

This gives you the best of both worlds: bounded references that look like ranges, but auto-adjust as you add or remove rows from the table.

The same pattern applies to FILTER, SORT, and RANDARRAY. If you feed them an entire column, you’re asking Excel to generate a result as tall as a worksheet. Keep your source ranges proportional to your actual data.

Fix 4: #SPILL! in VLOOKUP and Why XLOOKUP Is a Safer Upgrade

Here’s a trap that catches people who’ve used VLOOKUP for years. They write a formula intended for a single lookup:

=VLOOKUP(E1, A:B, 2, 0)

But in a moment of haste, they accidentally reference a range of lookup values:

=VLOOKUP(E1:E20, A:B, 2, 0)

What does this mean in modern Excel? You’re asking for twenty VLOOKUP results — one for each lookup value from E1 to E20 — and Excel treats the whole thing as a dynamic array. If the cells below your formula are occupied, you get #SPILL!. If they’re free, the formula will happily spill twenty results down the column.

There are two clean solutions:

Option A: Clear the vertical range. If you genuinely want twenty results, ensure the destination range is empty and let the formula spill.

Option B: Upgrade to XLOOKUP. XLOOKUP handles arrays natively and behaves the way users intuitively expect. The equivalent formula is:

=XLOOKUP(E1:E20, A:A, B:B)

No Ctrl+Shift+Enter. No cryptic error handling. Just an array that spills naturally.

If you’re on a legacy version of Excel where XLOOKUP isn’t available, the classic INDEX/MATCH combination does the same job:

=INDEX(B:B, MATCH(E1:E20, A:A, 0))

Entered with Ctrl+Shift+Enter in older Excel versions, this formula will return an array of results.

One more scenario: what if your original VLOOKUP was really meant to return just one value — for one lookup key — but it’s producing #SPILL! because Excel misread your intent? Prefix the lookup range with @:

=VLOOKUP(@E1:E20, A:B, 2, 0)

This forces implicit intersection and returns only the value at the formula’s row. In practice, I rarely recommend keeping VLOOKUP in new workbooks. But if you’re maintaining a legacy file, the @ operator is your escape hatch.

Fix 5: Spill Range Merged — Unmerge Cells or Use Center Across Selection

Merged cells are the enemy of dynamic arrays. If your formula wants to spill into a range that includes even one merged cell, Excel returns a #SPILL! error. Merged cells break the strict cell-per-value grid that spilled arrays depend on.

This often happens in beautifully formatted reports where someone merged cells for visual appeal:

• B3 and C3 merged together for a heading, with =SEQUENCE(5) starting in B2 → the second result wants to land in B3 → B3 is part of a merged group → error.

The fix is straightforward:

1. Select the merged cells.
2. Go to Home → Merge & Center → Unmerge Cells.
3. Re-enter your formula.

If you merged cells for visual centering, there’s a better tool that won’t sabotage your formulas: Center Across Selection. It centers text across selected cells without actually merging them into one cell. Find it under Format Cells → Alignment → Horizontal → Center Across Selection.

I’ve written before about why I avoid merged cells in operational spreadsheets, and this is the poster-child example. They make your reports look neatly organized — and then they silently block the very formulas that would have automated those reports.

---

How to Reference a Spill Range: Spill Formula Examples and the # Operator

Once your spill formulas are running smoothly, you’ll quickly discover a new question: how do you refer to a dynamic result that changes size? A normal reference like =SUM(B2:B6) breaks when the spill range grows to B2:B20 next week.

The # Spill Range Operator for Flexible Dynamic References

Excel provides a beautifully elegant solution: the # operator. If your formula spills from cell B2, you can reference the entire spill range with:

=B2#

That single character tells Excel, “Use whatever range B2 currently spills into.” If your UNIQUE formula in B2 outputs 50 names today and 500 tomorrow, =COUNTA(B2#) recalculates automatically to count them all.

This becomes a game-changer for building dashboards. Instead of maintaining static ranges that grow stale as your data changes, you create a chain of dynamic formulas that feed each other.

A few practical examples:

=SUM(B2#)
=SORT(B2#, 1, -1)
=XLOOKUP("Acme Corp", B2#, C2#)

The # operator is the connective tissue of modern spreadsheet design. Whenever you need a dependent formula to automatically adapt when the source array expands or contracts, reference that source by its anchor cell plus the # sign.

[Visual: animated GIF showing =SUM(B2#) automatically expanding as new rows are added to a spilled UNIQUE list.]

Spill to the Right: Horizontal Spread Patterns and Dynamic Arrays

New Excel users often assume spills only go downward. They don’t. Dynamic arrays can spill to the right, and even in both directions simultaneously.

Consider:

=SEQUENCE(5, 2, 1, 1)

This generates 5 rows and 2 columns — a grid that spills down and to the right:

The same two-dimensional behavior shows up in practical formulas like:

=SORT(FILTER(A2:C100, A2:A100 = "Open"), 2, 1)

Here, FILTER returns every row from A2:C100 where column A is “Open,” and SORT orders the whole result set by column B. The output occupies multiple rows and multiple columns — down and right.

The rule to internalize: your formula needs a clean rectangular space in every direction its output might grow. When you’re laying out a worksheet, leave whitespace around dynamic arrays. Nothing wrecks a dashboard faster than a beautifully-designed FILTER output colliding with a report title sitting to its right.

---

How to Use Spill in Excel Formula Workflows (Not Just Fix Them)

So far, this article has treated spill like a problem to solve. I want to flip that framing now. Once you master dynamic arrays, you won’t think of spill as an error at all — you’ll think of it as one of Excel’s most productive features.

Modern Spill Formulas: SORT, FILTER, UNIQUE, SEQUENCE

The dynamic array family of functions — SORT, FILTER, UNIQUE, SEQUENCE, and RANDARRAY — lets you do things that were genuinely difficult with legacy formulas.

Here’s a real workflow I built recently for a client who needed a weekly sales review:

=UNIQUE(A2:A100)

This creates a clean, always-current list of sales regions. No pivot table refresh required. No copying the formula down and cleaning up #N/A errors. The list updates itself the moment source data changes.

Want only the regions with open deals, sorted by deal value? One formula:

=SORT(FILTER(A2:C100, B2:B100 = "Open"), 2, 1)

This returns the matching rows, sorted by column B. In legacy Excel, the equivalent required an array formula entered with Ctrl+Shift+Enter — or, more often, a helper column, a manual sort, and a prayer.

SEQUENCE deserves special attention for date-focused work. To generate a month of dates starting from a specific date:

=SEQUENCE(30, 1, DATE(2025,1,1), 1)

This creates 30 sequential dates — instantly useful for building a calendar table, a project timeline, or a staffing schedule.

What makes these formulas remarkable is their liveness. Google Sheets users have had similar array behavior for years. In Excel, these functions respond to source-data changes immediately, without macros or manual refreshes. Your reports go from “snapshot” to “living dashboard” in one formula.

Excel Spill vs Google Sheets: Similar Dynamic Array Behavior in Other Spreadsheet Apps

If you work across both Excel and Google Sheets, you may have noticed that Sheets handled dynamic arrays a bit differently. Both tools now support native array output — a single formula returning values across adjacent cells. The difference is in the error-handling and syntax.

Google Sheets treats arrays differently in a few important ways:

• In Excel, dynamic arrays are the default for supported formulas. In Google Sheets, you sometimes need ARRAYFORMULA() to force older functions to process ranges as arrays.
• When an output range is blocked, Excel displays a specific #SPILL! error. Google Sheets generally shows a #REF! error — with a message identifying the blocking cell — rather than a dedicated spill error.
• The # operator for referencing spill ranges does not exist in Google Sheets in the same form. Sheets users often rely on FILTER() or direct range references within other functions instead.

For teams deciding between the two platforms, the practical takeaway is this: both can handle modern dynamic workflows. Excel has a more polished error system for arrays. Sheets tends to be more forgiving with some functions but more demanding with array wrapping. Neither is objectively better — it’s about matching the tool to your team’s habits.

---

Excel Spill Not Working: Fixing Older Versions and Unsupported Environments

Every so often, someone writes to me with a formula that should work — they have the modern function names, the right syntax, the proper layout — and yet Excel still refuses to spill. In almost every case, the problem isn’t the formula. It’s the environment.

Does Excel 2019 or Excel 2021 Support Spill? Check Your Version

Dynamic arrays — and therefore excel spill behavior — are not available in every version of Excel. This is the source of more confusion than almost any other Excel feature rollout.

Here’s the version matrix I share with clients:

For legacy Excel users, the fallback is the old-school approach: select the output range, type the formula, and press Ctrl+Shift+Enter to create a CSE array formula. The formula will display with curly braces {} and will perform the calculation — but it won’t behave like a modern dynamic array. It won’t auto-expand, and it won’t show a blue border.

Given how central dynamic arrays have become to modern Excel workflows, I’ll be direct: if you use Excel professionally and your organization is still on a pre-2021 perpetual license, it’s worth making the business case for an upgrade. The productivity gap is substantial.

Excel Spill Unavailable: Fixing Mac, Web and Microsoft 365-Specific Conditions

Dynamic arrays can also fail to work on versions that should support them. When this happens, the issue usually falls into one of these buckets:

• Outdated build. Microsoft pushes Excel features through monthly update channels. If your last update was six months ago, you may lack a fix for a spill-related bug. Go to File → Account → Update Options → Update Now and install any pending updates.
• Compatibility mode. Workbooks originally created in Excel 2016 or earlier sometimes open in Compatibility Mode, which disables modern features. Check the title bar — if you see “Compatibility Mode” next to the filename, go to File → Info → Convert to upgrade the workbook.
• Automatic calculation turned off. Dynamic arrays depend on Excel’s calculation engine to determine output size. If calculation is set to Manual, spill ranges may not expand correctly. Press Ctrl+Alt+F9 to force a full recalculation of all open workbooks (on a Mac, use the equivalent full-calc command under Formulas → Calculation).
• Excel for the web quirks. The browser version of Excel supports spill, but very large datasets may perform poorly because the server calculates results remotely. If your spill formulas crawl in Excel for the web, test the same workbook in the desktop app before assuming a formula problem.

One honest limitation: I’ve occasionally seen spill ranges behave unpredictably when a workbook contains volatile functions like OFFSET, INDIRECT, or legacy RAND() in heavy use. These functions recalculate constantly, which can make a dynamic array appear to “change size” on its own as Excel recalculates. In those cases, I usually recommend replacing volatile functions with non-volatile alternatives like INDEX wherever possible.

---

Frequently Asked Questions About Excel Spill Errors

How do I fix a #SPILL! error in Excel?

Click the formula cell and look for the blue dashed outline that shows the intended spill range. Then click the error icon next to #SPILL! and choose Select Obstructing Cells. If Excel highlights a blocker, clear those cells with Home → Clear → Clear All, or move them out of the way, then re-enter your formula. If no obstruction appears, check for one of the other classic triggers: merged cells in the spill area, the formula being inside an Excel Table, or a reference that targets an entire column and returns more results than Excel can display.

What does spill mean in Excel?

Spill is the behavior where a single Excel formula returns multiple results into a contiguous block of adjacent cells. That block is called the spill range and is outlined in blue. For example, =SEQUENCE(5) entered in B2 fills B2:B6 with the numbers 1 through 5. This functionality is powered by dynamic arrays, available in Microsoft 365 and Excel 2021/2024. The #SPILL! error appears when something blocks the formula’s intended output range.

How do I reference a spill range in Excel?

Use the # operator after the anchor cell. If your formula spills from B2, =B2# references the entire output range dynamically. So =SUM(B2#) totals everything in the spill range — and automatically adapts if the range expands or contracts as your source data changes. This is the cleanest way to build dependent formulas that stay in sync with dynamic arrays.

How do I turn off spilling in Excel?

You can’t turn off spill behavior entirely in versions that support it — dynamic arrays are built into the calculation engine. But you can prevent a specific formula from spilling by using the @ operator, which forces implicit intersection. For example, =@UNIQUE(A2:A100) returns only the first value from the unique list rather than spilling the entire list. Use this when you want a single result from a function that would otherwise produce multiple values.

Why is my spill range blank in Excel?

A visually blank cell can still block a spill range. Cells containing empty strings (""), stray spaces, transparent shapes, or hidden formatting all count as obstructions to Excel’s calculation engine. When you click the error icon, Excel may show a dotted border around cells that look empty but contain something. Select those cells and check the Name Box — you’ll often find a formula, a space, or a hidden object that you couldn’t see on screen.

Does Excel 2019 support dynamic array spill?

No. Dynamic arrays, spill behavior, and the # spill operator were introduced in Microsoft 365 and Excel 2021/2024. Excel 2019 and all earlier versions use the legacy calculation engine, which requires Ctrl+Shift+Enter array formulas for multiple results. If you see #NAME? when typing =UNIQUE or =FILTER on an older version, that’s why.

---

Final Takeaway: Give Your Spill Formulas Room to Breathe

Here’s what I hope you remember an hour from now: the excel spill error is not your enemy. It’s a diagnostic message written by Excel’s calculation engine, and it tells you exactly where your layout is preventing a dynamic array from delivering its full result set.

The four dominant root causes are:

1. Obstructed spill range — something visible or invisible occupies the target cells.
2. Merged cells — merged cells break the one-value-per-cell contract.
3. Full-column references — formulas like =UNIQUE(A:A) ask Excel to spill more rows than a worksheet can hold.
4. Excel Tables — structured tables can’t host formulas that dynamically expand beyond a single row.

When you clear those blockers, something shifts. You stop fighting the error and start using the feature. You build a FILTER formula that powers an entire report dashboard. You write =SORT(UNIQUE(...)) and watch a ten-step manual process collapse into one cell. You start designing spreadsheets the way modern Excel intends: with space reserved for output, with source ranges clearly bounded, and with formulas that do the heavy lifting.

If you want to practice what you learned today, here’s my recommendation. Create a small dummy dataset of, say, 50 rows of sales transactions. In a blank region of your sheet, try =UNIQUE(A2:A100). Next to it, try =SORT(FILTER(A2:C100, B2:B100="Open"), 2, 1). Watch what happens when you edit a source row, add a new record, or type something into the spill range. Intentional practice beats reading every time.

Want a ready-made Spill Practice Workbook with pre-built examples of every fix in this guide? Download it, take it apart, and make it your own. And if a particular #SPILL! scene has you stumped — the kind where you’ve cleared cells, checked for merges, and still get the error — drop a comment describing your setup. I answer every one I can, and I’ll do my best to give you a personal diagnostic within 24 hours. Sometimes describing the layout out loud is all it takes to spot the invisible blocker.

Give your formulas room to breathe. They’ll do the rest.