Auditing & Troubleshooting Formulas

Excel Advanced

Chapter 9 · Auditing & Troubleshooting Formulas

Eight chapters of building increasingly ambitious formulas, automations, and data models raises an obvious question: what happens when one of them breaks, or worse, silently produces the wrong answer with no error at all? This chapter covers Excel's own error values and its built-in auditing tools — the ones that turn "something's wrong somewhere in this workbook" into "here, specifically, is what's wrong."

Excel's Error Values: What Each One Actually Means

Every error value this course has encountered along the way, gathered in one place:

ErrorWhat it actually meansWhere this course first saw it
#DIV/0!Division by zeroExcel Fundamentals — any formula dividing by an empty or zero cell
#N/AA lookup found no matchExcel Fundamentals Ch.5 — XLOOKUP with no matching value
#VALUE!A formula received the wrong type of value (e.g. text where a number was expected)Excel Fundamentals Ch.4 — concatenating a number without str-equivalent handling
#REF!A formula refers to a cell that no longer exists (usually after a row/column was deleted)Any formula whose referenced cell is later deleted
#NAME?Excel doesn't recognise a function name or defined name — often a typoAny misspelled function name
#SPILL!A dynamic array's result has nowhere to spill intoExcel Advanced Ch.1 — UNIQUE/SORT/FILTER blocked by occupied cells
#CALC!A dynamic array function's calculation itself failed (e.g. FILTER matching nothing, with no if_empty argument given)Excel Advanced Ch.1 — FILTER with no fallback

Trace Precedents & Trace Dependents

Formulas → Trace Precedents draws arrows from the selected cell back to every cell that feeds into it. Formulas → Trace Dependents draws arrows forward, showing every other formula that relies on the selected cell. On a workbook the size of Excel Fundamentals Chapter 10's Budget Tracker — or this course's own Data Model relationships (Chapter 5) — these arrows turn "which cells actually affect this number" from a manual hunt into a single click.

Error Checking & the Watch Window

Formulas → Error Checking walks through every cell Excel has flagged as containing a likely error, one at a time, with a plain-language explanation and the option to trace its precedents directly from the same dialog. The Watch Window (Formulas → Watch Window → Add Watch) keeps a specific cell's current value visible in a small floating panel, even while you're actively editing a completely different worksheet — useful for confirming a distant total updates the way you expect while you work on the data feeding it.

Evaluate Formula: Stepping Through a Calculation One Piece at a Time

Formulas → Evaluate Formula steps through a nested formula one function call at a time, showing the actual underlying value at each stage before moving to the next. This is precisely the "read from the innermost parentheses outward" technique this course has used informally since Excel Fundamentals Chapter 4's nested IF and Excel Advanced Chapter 2's nested XLOOKUP — except now it's an actual built-in tool doing the tracing for you, rather than working it out by hand on paper.

IFERROR and IFNA: Catching Errors Gracefully

IFERROR wraps any formula, catching whatever error it produces and substituting a fallback value instead:

=IFERROR(A1/B1, 0) → if A1/B1 produces #DIV/0! (or any other error), show 0 instead

IFNA is narrower — it only catches #N/A specifically, letting every other error type through unchanged:

=IFNA(XLOOKUP(D1, A:A, B:B), "Not found") → catches a genuine "no match" from XLOOKUP specifically, but still shows a real #REF! or #VALUE! if one of those occurs instead

That distinction matters more than it looks: a broad IFERROR around a lookup would just as happily swallow a genuine typo in the range address (a real #REF!, meaning something is actually broken) as it would a legitimate "no match found," displaying the same harmless-looking fallback value either way — with no way to tell, just by looking at the result, which situation actually occurred.

Circular References: When a Formula (Indirectly) Refers to Itself

A circular reference occurs when a cell's formula depends — directly or through a chain of other cells — on its own value. Excel shows a warning dialog the moment one is created, and the cell typically displays 0 or the last successfully calculated value instead of a real result. The single most common accidental cause: summing a range that includes the very cell the total is being written into.

Cell A11, intended as the total of A1:A10, accidentally written as: =SUM(A1:A11) → A11 now includes ITSELF in its own sum — a circular reference

Formulas → Error Checking → Circular References lists every cell currently involved in a circular chain, which is genuinely necessary once the loop passes through several cells rather than a single obvious one like the example above.

ToolThe question it answers
Trace Precedents"What feeds into this formula?"
Trace Dependents"What else relies on this cell?"
Evaluate Formula"What does this nested formula actually compute, step by step?"
Watch Window"Did this distant cell's value just change while I was working elsewhere?"
Evaluate Formula is the "read from the inside out" habit, built directly into Excel
Every nested-formula example across this entire course — Fundamentals Chapter 4's grading bands, Advanced Chapter 2's two-dimensional XLOOKUP — was read by mentally resolving the innermost function first and treating its result as a plain value for the next layer out. Evaluate Formula performs exactly that same process for you, one visible click at a time, on any nested formula in the workbook.
Wrapping every formula in IFERROR to "clean up" a sheet hides real bugs
A blanket habit of wrapping every formula in IFERROR(..., "") or IFERROR(..., 0) makes a worksheet look tidy, but it also silently swallows genuine problems — a real typo in a range, a broken reference after a row was deleted, a formula that should never have been able to fail at all — behind a blank cell or a plausible-looking fallback number that gives no indication anything went wrong. Reserve IFERROR/IFNA specifically for errors you've identified as genuinely expected and survivable (a lookup that legitimately might not find a match); let every other error surface visibly so it actually gets investigated and fixed.

Hands-On Exercises

Exercise 1

A cell shows #REF!. Another cell, using the exact same lookup formula, shows #N/A instead. Explain what each of these two errors actually indicates about its cell's formula, and describe one realistic action that would have caused each one specifically.

📄 View solution
Exercise 2

A colleague wraps a VLOOKUP in IFERROR(VLOOKUP(...), "") to hide any error, "just in case." Explain a realistic scenario where this specific choice could hide a genuine bug rather than just a harmless missing lookup value, and rewrite it using the more precise alternative this chapter introduces.

📄 View solution
Exercise 3

Cell B11 is meant to hold the total of B1:B10 but currently shows 0 with a circular reference warning. Diagnose the most likely cause and state the corrected formula. Then describe which specific auditing tool from this chapter would have made the mistake visible immediately, before Excel's own warning even appeared.

📄 View solution

Chapter 9 Quick Reference

  • #DIV/0!, #N/A, #VALUE!, #REF!, #NAME?, #SPILL!, #CALC! — each means something specific; see this chapter's own error table
  • Trace Precedents / Trace Dependents — arrows showing what feeds a formula, or what relies on a cell
  • Evaluate Formula — steps through a nested formula one function call at a time
  • Watch Window — keeps a specific cell's value visible while working elsewhere in the workbook
  • IFERROR catches any error; IFNA catches only #N/A, letting genuine other errors surface
  • Circular reference — a formula that depends, directly or indirectly, on its own cell; often caused by a SUM range accidentally including its own total cell
  • Reserve IFERROR/IFNA for genuinely expected, survivable errors — don't use it to blanket-hide every possible mistake