Twelve Monthly Tabs, One Total: 3D References, INDIRECT and the 47,500 Nobody Booked

The workbook is called 2026 Bookings. Twelve tabs — Jan through Dec — each one a copy of the same template, each one totalling to row 14. On the summary sheet there is a single cell:

=SUM(Jan:Dec!E14)   →   1,735,250

Somebody adds the twelve tabs up on paper. They get 1,687,750.

Nothing is broken. No cell is red, no error appears, the formula is spelled correctly and it is pointing at exactly what it says it is pointing at. The 47,500 difference is a tab called Adjustments that a colleague created in March, used twice, and dragged out of the way — into the gap between Aug and Sep, which is the one place in that workbook where a sheet is invisible to the eye and included in the arithmetic.

That is the shape of nearly every multi-sheet bug: a formula that is correct about a workbook that has quietly changed underneath it. This article is about the three honest ways to add up a stack of tabs — the 3D reference, INDIRECT, and a query — what each one is actually promising you, and which failures each one leaves on the table.

What you need. Sections 1 to 10 work in every version of Excel this century, on Windows, Mac, the web and Google Sheets, with the exceptions flagged where they appear. VSTACK in section 11 is Microsoft 365 and Excel 2024 only. Power Query in section 12 is Excel 2016 and later on Windows, and 2021 and later on Mac.

1) The Summary That Cannot Be Reconciled

🎯 Scenario: A finance lead asks why the bookings number on the board is 1,735,250 when the sum of the twelve monthly reports is 1,687,750. Nobody has touched a formula in six months.

The grid above is the honest version — one row per monthly tab, with what each tab totals to. Total it and the arithmetic is not in dispute:

Twelve rows, twelve tabs, one total. The number on the board is 47,500 higher, and the gap is a thirteenth sheet that no row here represents.

The reason a person cannot find that sheet by looking is that they are looking for a name in a formula, and the formula does not contain names in the way they think. Jan:Dec! is not shorthand for "the twelve sheets I mean". It is shorthand for "everything from the tab called Jan to the tab called Dec, in tab-strip order, whatever that turns out to be today". Excel resolves it fresh on every calculation.

So the audit question is never "is the formula right". It is "how many sheets does this formula currently cover, and can I see that number". Section 4 makes it visible in one cell. Section 5 makes it stop mattering.

2) The Sheet Reference: What Jan!E14 Actually Stores

Before the three-dimensional version, the one-dimensional one. Click a cell on another tab while writing a formula and Excel types this for you:

=Jan!E14              a cell on another sheet in the same workbook
=Jan!$E$14            the same cell, anchored
='Q1 Detail'!E14      apostrophes, because the name has a space in it
=[2025.xlsx]Dec!E14   another workbook, while that workbook is open
='C:\Reports\[2025.xlsx]Dec'!E14    the same, once it is closed

Four rules that explain every quoting question you will ever have about these:

• Apostrophes are required when the sheet name contains a space, and also when it contains a hyphen, a bracket, or begins with a digit. '2026 Q1'!A1 needs them. Jan!A1 does not. Excel adds them itself when it can; it is when you are building the string yourself, in section 8, that this becomes your problem.
• An apostrophe inside the name is doubled. A tab called John's Notes is written 'John''s Notes'!A1.
• The exclamation mark separates sheet from cell, and it lives outside the quotes, always. 'Q1 Detail'!E14, never 'Q1 Detail!E14'.
• The reference follows the sheet. Rename Jan to January and every =Jan!E14 in the workbook silently rewrites itself to =January!E14. Move the tab, and nothing changes at all — a plain sheet reference is by name, and the name is what Excel is tracking. Remember that, because in section 8 the exact opposite is true and it catches everybody.

Delete the Jan sheet, though, and every formula pointing at it becomes =#REF!E14. There is no undoing that from the formula's side; the reference has nothing left to point at.

3) The 3D Reference, and the Eighteen Functions That Take One

A 3D reference is the range operator applied to the sheet axis instead of the row and column axes:

=SUM(Jan:Dec!E14)          one cell, on every sheet from Jan to Dec
=SUM(Jan:Dec!E2:E13)       a whole range, on every sheet from Jan to Dec
=AVERAGE(Jan:Dec!E14)      the mean of the twelve monthly totals
=MAX(Jan:Dec!E14)          →  190,150   (November)
=MIN(Jan:Dec!E14)          →   89,250   (August)
=COUNT(Jan:Dec!E14)        →       12   how many of them hold a number

That last one is the audit formula from section 1, and it is worth putting in a corner of the summary sheet permanently. If =COUNT(Jan:Dec!E14) says 13, the sandwich has an extra sheet in it, and it says so before anybody has to reconcile anything by hand.

The catch is that only a short list of functions accepts a 3D reference at all. It is worth knowing by heart, because the ones that do not fail in a way that looks like a typo:

Eighteen functions, all of them aggregations that reduce a pile of numbers to one number. Nothing else. SUMIF is not on the list. Neither is VLOOKUP, INDEX, FILTER, SUMPRODUCT, TEXTJOIN or anything that arrived after 2019. Section 7 is about what to do instead.

Two conveniences while you are here. First, you can build one by pointing: type =SUM(, click the Jan tab, hold Shift and click the Dec tab, then click E14 and press Enter. Excel writes the syntax. Second, a 3D reference can live inside a defined name, which is the closest thing to documentation this technique has:

Name Manager  →  New  →  Name: AllMonthsNet
                         Refers to: =Jan:Dec!$E$14

=SUM(AllMonthsNet)     →   1,687,750

Now the summary sheet reads =SUM(AllMonthsNet) and there is one place — not forty formulas — to look when the answer is wrong.

4) Position, Not Name: The Tab Somebody Dragged

Here is the mechanism the whole first half of the article turns on.

Jan:Dec! does not mean the sheets named Jan and Dec and the ten named ones in between. It means every sheet whose position in the tab strip lies between the position of Jan and the position of Dec. Excel evaluates that on every recalculation, against the tab strip as it stands at that moment.

Four things people do to a workbook, and what each one does to =SUM(Jan:Dec!E14):

Every row of that table is a silent change of several hundred thousand, and none of them is a bug in Excel. The formula asked for a span of the tab strip; the tab strip moved.

The last row is the one that surprises people most. Deleting an endpoint does not produce #REF! the way deleting the target of =Jan!E14 does. Excel treats the endpoint as a boundary and slides it to the next surviving sheet, so the formula stays green and the answer changes. Drag Dec to the front of the tab strip and the same logic applies from the other side: the two bookends are now adjacent, so the sandwich has almost nothing in it, and a twelve-month total becomes a two-month one without a single warning.

The three symptoms, so you can recognise this from the outside:

1. The total is wrong by exactly one tab's worth of something.
2. =COUNT(Jan:Dec!E14) returns a number that is not the number of months.
3. Nobody edited a formula. Somebody reorganised tabs, which nobody thinks of as editing.

5) The Bookend Trick

The fix is not discipline. Discipline is what fails here — the whole point is that reorganising tabs does not feel like touching a formula, so no amount of care prevents it.

The fix is to make the boundaries into sheets whose only job is to be boundaries:

1. Insert an empty sheet at the far left of the strip and call it Start.
2. Insert an empty sheet at the far right and call it End.
3. Write every roll-up as =SUM(Start:End!E14).
4. On both sheets, put one sentence in A1: "Do not move, delete or put anything on this sheet. Formulas on Summary add up everything between these two."

Now the failure modes invert, and in your favour:

• A new monthly tab dropped anywhere between the bookends is included automatically. That is exactly what you want in January, and it is the one thing a hand-written =Jan!E14+Feb!E14+… chain can never do.
• Nobody can accidentally exclude a month by dragging it, because there is nowhere outside the bookends to drag it to except past a sheet that says do not do that.
• Deleting a month still removes its figure — but a missing month is a visible thing, and =COUNT(Start:End!E14) on the summary reports it.

The cost is that a scratch sheet dropped between the bookends is still swallowed. So pair the bookends with the count:

=COUNT(Start:End!E14)                        →  12
=IF(COUNT(Start:End!E14)<>12,"CHECK TABS","")

Two cells. One of them says CHECK TABS on the morning somebody parks an Adjustments sheet in the middle of your workbook, which is the morning you want to hear about it rather than the afternoon of the board meeting.

6) The Same Cell on Every Tab: Grouping, and the Template That Makes This Possible

A 3D reference reads the same address on every sheet. Jan:Dec!E14 is twelve copies of E14. If November's total sits in E15 because somebody inserted a row for a note, then November's total is not in the sum — E15's blank is, and blanks add nothing. The total is short by 190,150 and the formula is, once again, correct.

So the technique has a prerequisite that is really a habit: identical layout on every tab. Two features make that cheap.

Group the sheets. Click Jan, hold Shift, click Dec. The title bar says [Group] and every keystroke lands on all twelve sheets at once — type a header, insert a row, format a column, and the tabs stay in step by construction. The one rule: click a single tab to ungroup the moment you are done. People forget, then type a January note onto all twelve months. If the title bar says [Group], you are editing everything.

Keep a template tab. One sheet called Template, hidden, holding the empty monthly layout. New month: right-click → Move or Copy → Create a copy, rename to the month, drag inside the bookends. Every tab has the same shape because every tab came from the same shape.

And a diagnostic for when you inherit a workbook rather than build one — put this on the summary sheet and fill it across:

=COUNTA(Start:End!E14)-COUNT(Start:End!E14)     →  0

COUNTA counts anything, COUNT counts only numbers, and the gap is the number of tabs whose E14 holds something that is not a number — a stray label, an error, a note. Zero means the column is clean. Anything else names how many tabs to go and look at.

7) What a 3D Reference Cannot Do

Now the wall. You have twelve tabs of transactions and you want the refunds only:

=SUMIF(Jan:Dec!$B$2:$B$500,"Refund",Jan:Dec!$E$2:$E$500)    →   #VALUE!
=VLOOKUP("SKU-4105",Jan:Dec!$A:$F,5,FALSE)                  →   #VALUE!
=FILTER(Jan:Dec!A2:F500,Jan:Dec!B2:B500="Refund")           →   #VALUE!

All three are the same refusal. Anything outside the eighteen aggregations in section 3 sees a 3D reference and cannot make a 2D array out of it, so you get #VALUE! — an error message that says "wrong kind of value" when what it means is "wrong number of dimensions". No argument order fixes it and no anchoring fixes it.

The workaround for the conditional aggregates is the one multi-sheet pattern worth memorising. Put the sheet names in a real range — A2:A13 of the summary grid above already is one — and hand SUMIF twelve separate references, then add up its twelve answers:

=SUMPRODUCT(SUMIF(INDIRECT("'"&$A$2:$A$13&"'!$B$2:$B$500"),
                  "Refund",
                  INDIRECT("'"&$A$2:$A$13&"'!$E$2:$E$500")))

Read it inside out. INDIRECT("'"&$A$2:$A$13&"'!$B$2:$B$500") is twelve strings built from twelve sheet names, each turned into a real reference. SUMIF runs once per reference and returns an array of twelve subtotals. SUMPRODUCT adds the array up — and it is there specifically because it evaluates arrays without needing Ctrl + Shift + Enter in older Excels.

The same shape covers the rest of the family:

Count matching rows   =SUMPRODUCT(COUNTIF(INDIRECT("'"&$A$2:$A$13&"'!$B$2:$B$500"),"Refund"))
Two conditions        =SUMPRODUCT(SUMIFS(INDIRECT("'"&$A$2:$A$13&"'!$E$2:$E$500"),
                                         INDIRECT("'"&$A$2:$A$13&"'!$B$2:$B$500"),"Refund",
                                         INDIRECT("'"&$A$2:$A$13&"'!$C$2:$C$500"),"EMEA"))
Per-tab, filled down  =SUMIF(INDIRECT("'"&$A2&"'!$B$2:$B$500"),"Refund",
                             INDIRECT("'"&$A2&"'!$E$2:$E$500"))

That last one is the one to reach for first. Filled down beside the sheet names it gives you twelve visible subtotals instead of one opaque number, and when the answer is wrong you can see which tab is wrong. A single SUMPRODUCT that returns 52,850 tells you nothing about where 52,850 came from.

For lookups, the honest answer is usually a helper column that says which sheet a record lives on, then one INDIRECT:

=VLOOKUP($A2,INDIRECT("'"&$B2&"'!$A:$F"),5,FALSE)

If you genuinely do not know which tab holds the record, you can scan for it — MATCH(TRUE, COUNTIF(INDIRECT(…),key)>0, 0) finds the first sheet whose column A contains the key, and you feed that name back into an INDIRECT lookup. It works. It is also twenty-four range scans per row, entered as an array formula, and it is the point at which the answer stops being a formula and starts being section 12.

8) INDIRECT: Building the Sheet Name Out of a Cell

Everything in section 7 rested on INDIRECT, which deserves its own look, because it behaves in exactly the way people do not expect.

INDIRECT takes text and returns the reference that text describes:

=INDIRECT("Jan!E14")            →   125,300
=INDIRECT("'"&A2&"'!E14")       →   the E14 of whichever sheet A2 names
=INDIRECT("'"&A2&"'!"&B2)       →   sheet from A2, cell address from B2

The quoting in the second one is the part everybody gets wrong, so take it apart. You need the string 'Jan'!E14. The apostrophes are literal characters, and in Excel a literal apostrophe inside a text string is written "'". So:

"'"  &  A2  &  "'!E14"
 '      Jan     '!E14

Always include the apostrophes, even when the sheet name has no space in it. 'Jan'!E14 is perfectly valid, and the day someone renames a tab to Q1 Detail the formula that already has them keeps working while the formula that does not returns #REF!.

Now the four properties that decide whether you should be using it at all:

It breaks on rename, and a plain reference does not. This is backwards from every intuition about which reference is more robust. =Sept!E14 is a reference; rename the tab to Sep and Excel rewrites the formula for you. =INDIRECT("Sept!E14") is a string that happens to look like a reference; Excel has no idea it is one, does not rewrite it, and the formula returns #REF! from the moment the tab is renamed. Which is why the pattern in section 7 reads its names from cells: rename a tab, fix the one cell, and every formula follows.

It is volatile. Every INDIRECT recalculates on every change anywhere in the workbook, along with everything downstream of it. A dozen is free. The array version from section 7, filled down two hundred rows, is a spreadsheet that pauses when you type.

It cannot see a closed workbook. =INDIRECT("'C:\Reports\[2025.xlsx]Dec'!E14") works while 2025.xlsx is open and returns #REF! the second it closes. A plain external link keeps its last cached value. If you are pulling from other files, do not build the reference with INDIRECT.

It is invisible to auditing. Trace Precedents draws no arrow from an INDIRECT. Find & Replace does not see the sheet name inside the string. Nothing in Excel can tell you that the summary depends on the Aug tab. The dependency is real and untraceable, which is a good reason to keep the sheet names in visible cells rather than hard-coded inside the strings.

9) The Sheet That Knows Its Own Name

The mirror image of section 8: instead of building a reference from a name, read the name of the sheet a formula is sitting on. There is no SHEETNAME() function, so the classic is:

=MID(CELL("filename",A1),FIND("]",CELL("filename",A1))+1,255)     →   Jan

CELL("filename",A1) returns the full identity of the file and sheet — C:\Reports\[2026 Bookings.xlsx]Jan — and everything after the closing bracket is the tab name. FIND locates the bracket, MID takes the rest. In Microsoft 365 the same thing is readable:

=TEXTAFTER(CELL("filename",A1),"]")     →   Jan

Three warnings, all of which have cost somebody an afternoon:

• The A1 is not optional. CELL("filename") with no second argument reports the sheet containing the last cell that changed anywhere in the workbook. Leave it out and every tab's "own name" formula shows the same name — whichever sheet you typed on most recently — and it changes as you click around. Pass A1 and the answer is anchored to the sheet the formula lives on.
• The workbook must have been saved at least once. In a brand-new unsaved file, CELL("filename",A1) returns an empty string and the FIND fails with #VALUE!. Save the file and it starts working.
• CELL is volatile, with the same performance note as INDIRECT. Put it in one cell per sheet and point everything else at that cell.

Used well, this closes the loop. Each monthly tab puts its own name in A1; the summary's roll-up formula reads names from a column; and when somebody renames a tab, the tab itself tells you what it is now called.

If your Excel has SHEET() and SHEETS() (2013 and later), they are worth knowing too: =SHEETS() returns the number of sheets in the workbook, and =SHEETS(Start:End!A1) returns how many sheets that 3D reference currently spans — the section 4 audit without needing a numeric cell to count.

10) Data → Consolidate: The Answer With No Formulas In It

Excel has shipped a consolidation command since long before any of this, and it is genuinely the right tool for one specific job: combining tabs whose rows do not line up.

Select the top-left cell of your output, then Data → Consolidate:

• Function — Sum, Count, Average, Max, Min, Product, and the standard deviation and variance pair.
• Reference — click into each source range and press Add. The list can span sheets and other open workbooks.
• Use labels in — tick Top row and Left column to consolidate by category rather than by position. This is the feature that matters: with labels ticked, a product that appears on eight of the twelve tabs, in a different row order on each, ends up on one row of the output with its eight figures added.
• Create links to source data — builds a grouped outline where every consolidated figure can be expanded into the individual sheet values that make it up, each one a live link.

Four things to know before you rely on it:

1. Without the links box ticked, the output is a paste of values. It does not update when a source sheet changes. Re-running the command is the refresh.
2. Labels must match exactly. Widget and Widget — one trailing space — become two rows, and this is the single most common reason a consolidation "loses" items. Run TRIM over the label columns first.
3. The source list is fixed at setup. A new monthly tab does not join the consolidation; you reopen the dialog and Add it.
4. Linked output inserts an outline column on the left and one row per source per item, which is informative and awkward to build a report on top of.

Consolidate is the fastest thing here for a one-off — quarterly packs, a merge of four regional files someone emailed you — and the wrong choice for anything that has to run again next month unattended.

11) VSTACK: Stacking the Tabs Instead of Totalling Them

Everything so far reduces twelve tabs to one number. Often what you actually want is twelve tabs as one long table, so a PivotTable or a FILTER can do the rest. In Microsoft 365 and Excel 2024:

=VSTACK(Jan!A2:F500, Feb!A2:F500, Mar!A2:F500)

There is no 3D form of this. =VSTACK(Jan:Dec!A2:F500) returns #VALUE! for the reason in section 7 — VSTACK is not one of the eighteen. You list the ranges, all twelve of them, and that list is the maintenance cost.

Two adjustments make the result usable. Padding the ranges out to row 500 leaves several thousand blank rows in the output, so filter them out; and a stacked table with no month column cannot tell you which tab a row came from, so tag each range as you stack it:

=LET(
    tag,  LAMBDA(name, rng, HSTACK(IF(CHOOSECOLS(rng,1)="", "", name), rng)),
    all,  VSTACK(tag("Jan",Jan!A2:F500),
                 tag("Feb",Feb!A2:F500),
                 tag("Mar",Mar!A2:F500)),
    FILTER(all, CHOOSECOLS(all,2)<>"")
)

tag glues a month column onto the left of a range, blank where the range is blank; all stacks the tagged ranges; FILTER drops the padding by testing the original first column. The output is a live table that re-sorts and re-totals itself the moment a monthly tab changes — which is the one thing Consolidate cannot do.

Two limits worth knowing. Ranges of different widths pad with #N/A — VSTACK squares the result off to the widest input, so a tab with an extra column contaminates every other row with errors, and IFERROR(…,"") around the whole thing hides the symptom rather than fixing the layout. And the spill needs room; anything sitting where the result wants to go returns #SPILL!.

12) Power Query: The Tab That Adds Itself

At some number of tabs, formulas stop being the answer. The threshold is not really a count — it is the moment the sheet list starts changing on its own. A workbook that gains a tab every month, or a folder that gains a file every week, is a query problem, because a query is the only one of these techniques where the list of sources is itself refreshable.

All the tables in the current workbook, appended, in four steps: Data → Get Data → From Other Sources → Blank Query, then in the formula bar:

= Excel.CurrentWorkbook()

That returns one row per table and named range in the file. Filter out the query's own output table, expand the Content column, and you have every monthly table stacked. Format each monthly tab's data as a Table (Ctrl + T) and a new month appears in the query the moment you refresh.

Every sheet in another workbook: Data → Get Data → From File → From Workbook, pick the file, and in the Navigator tick Select multiple items and then the folder icon at the top, which selects every sheet at once. Combine, and Power Query writes the append step for you.

Every workbook in a folder: Data → Get Data → From File → From Folder. This is the one that changes how a monthly process feels — drop next month's file into the folder, hit Refresh All, done. No formula, no dialog, no Add.

What you get, and what it costs:

• It picks up new sources by itself. The 3D reference does this within its bookends and nothing else here does it at all.
• The cleanup is stored. Promote headers, change types, trim the labels, unpivot the twelve month columns into rows — all of it replays on every refresh. Consolidate's label-matching problem from section 10 simply does not arise, because you fixed the labels in a step that runs every time.
• It is a load, not a live formula. Nothing updates until somebody hits Refresh, and on a slow source that takes seconds. A summary cell that must be correct the instant a monthly tab is edited should stay a 3D reference.
• It is a different skill. The Power Query article on this blog covers the editor properly; this is only the multi-sheet corner of it.

13) Which One to Use

And one rule that sits above the table: the technique should be no more clever than the workbook is stable. A model with twelve tabs that will still be twelve tabs in December wants a 3D reference and takes ten seconds to write. A model that gains a tab a month, gets reorganised by three people and feeds a board pack wants a query, and the afternoon it costs to build is cheaper than the first reconciliation it prevents.

Practice

Rebuild the workbook behind the grid — twelve sheets named for the months, each with its Net figure in E14, and a Summary sheet — then work through these.

1. The 47,500. Write =SUM(Jan:Dec!E14) on the Summary and confirm 1,687,750. Insert a sheet called Adjustments between Aug and Sep, put 47,500 in its E14, and watch the total become 1,735,250 without anything turning red. Then find the formula that would have told you.
2. The endpoint. Delete the Jan sheet and look at what the summary formula now says — the text of it, not just the answer. Explain in one sentence why this differs from deleting the target of =Jan!E14.
3. The bookends. Add Start and End sheets, rewrite the roll-up as =SUM(Start:End!E14), and try every way you can think of to exclude November from the total by dragging tabs. Then add the CHECK TABS cell from section 5.
4. The refusal. Try =SUMIF(Jan:Dec!$B$2:$B$500,"Refund",Jan:Dec!$E$2:$E$500) and read the #VALUE!. Then build the filled-down SUMIF(INDIRECT(…)) beside the sheet names in A2:A13 and check the twelve subtotals add to your refund total.
5. The rename. Put =Sep!E14 in one cell and =INDIRECT("Sep!E14") in the next. Rename the Sep tab to Sept and write down what each cell now shows, and which of the two behaved the way you expected.
6. The apostrophes. Rename a tab to Q3 Detail and point =INDIRECT(A2&"!E14") at it. Fix it with =INDIRECT("'"&A2&"'!E14") and explain what the "'" is doing.
7. The last cell you touched. Put =MID(CELL("filename"),FIND("]",CELL("filename"))+1,255) on three different tabs — deliberately without the A1. Type something on one tab and watch all three change. Then add the A1 and try again.
8. The growing folder. Split the twelve months into twelve one-sheet workbooks in a folder, load them with Power Query → From Folder, then add a thirteenth file and hit Refresh All. Compare the effort of that to adding a thirteenth tab to the VSTACK in section 11.

Summary

=SUM(Jan:Dec!E14) is one of the most useful things you can type into a spreadsheet and one of the easiest to be quietly wrong about, because the promise it makes is not the promise people hear. It does not add up the twelve sheets you have in mind. It adds up whatever currently lies between two positions in the tab strip, recalculated every time, and dragging a tab is not something anybody experiences as editing a formula. That is the whole of the 47,500: a scratch sheet parked in a gap, inside a span nobody could see the edges of.

Two cells fix it for good. Blank Start and End sheets turn the boundaries into objects that can be labelled and left alone, so a new month is included automatically and an old one cannot be dragged out. =COUNT(Start:End!E14) next to the total turns "how many sheets is this covering" from an archaeology problem into a number on the screen. Neither is clever, and together they retire the entire failure mode.

The limits are worth carrying in your head as one sentence: eighteen aggregating functions accept a 3D reference and nothing else does, which is why SUMIF across tabs is SUMPRODUCT(SUMIF(INDIRECT(…))) and not a 3D anything. INDIRECT is the tool that makes the rest of it possible and the one to be most careful with — volatile, blind to closed workbooks, invisible to Trace Precedents, and broken by exactly the rename that a plain reference sails through. Keep its sheet names in visible cells and all four problems get smaller.

Past that, the decision is about the workbook rather than the formula. A stable set of tabs wants a 3D reference. Ragged one-off tables want Data → Consolidate. Tabs that need to become one long table want VSTACK in a modern Excel. And the moment the list of sources starts changing on its own — a tab a month, a file a week — every formula in this article is maintaining a list by hand, and a query is the only technique here that maintains it for you.