Cell References — Relative vs. Absolute

Excel Fundamentals

Chapter 3 · Cell References: Relative vs. Absolute ($ Locking) and Why It Matters

Chapter 2 promised this chapter would explain why a formula's cell references "shift with each row" when you drag it down — and that shifting behaviour is exactly what this chapter is about. It turns out that shifting isn't always what you want, and Excel gives you a precise way to control it, one dollar sign at a time. Get this concept solid now, because every function in Chapter 4 onward depends on you being able to predict exactly what a formula will look like after it's been copied.

Relative References: The Default Behaviour

Every reference you type — A1, B7, C12 — is relative by default. A relative reference isn't really stored as "cell A1" at all; it's stored as something closer to "the cell two columns left and one row up from wherever I am." Copy or fill that formula somewhere else, and it re-applies that same relative offset from its new position.

Typed into B1: =A1*2 Fill handle dragged down to B2, B3, B4 — each reference shifts down by the same number of rows the formula itself moved: B2: =A2*2 B3: =A3*2 B4: =A4*2

This is exactly the behaviour you want almost all the time — a "double this row's value" formula genuinely should look at that row's input, not always the same fixed cell.

The Problem Relative References Create

Now imagine a worksheet with a single tax rate stored once, in cell B1, and a column of prices in A2:A10 that all need that same rate applied. In C2 you write a perfectly reasonable-looking formula:

Typed into C2: =A2*B1 Dragged down to C3, C4… both references shift, including B1: C3: =A3*B2 ← wrong! B2 is empty, not the tax rate C4: =A4*B3 ← wrong again, and getting worse

Nothing crashes and no error appears — the formula just silently multiplies by whatever happens to be sitting in a cell that has nothing to do with the tax rate. This is precisely the kind of bug this course's own Chapter 1 warned about: Excel will never tell you a number is conceptually wrong, only whether a formula is syntactically valid.

Absolute References: Locking Both Parts with $

An absolute reference pins a reference so it never shifts, no matter where the formula is copied. You create one by putting a dollar sign directly in front of the part you want locked — $B$1 locks both the column (B) and the row (1).

Typed into C2: =A2*$B$1 Dragged down to C3, C4 — A2 still shifts normally, but $B$1 never moves: C3: =A3*$B$1 C4: =A4*$B$1

Notice A2 is deliberately left relative — it should shift, since each row needs its own price. Only the tax-rate reference needs locking. This mix of "some parts relative, one part absolute" is completely normal in real formulas.

Mixed References: Locking Only the Column, or Only the Row

A dollar sign locks only whatever it directly precedes — which means you can lock just the column, just the row, or both:

ReferenceWhat's lockedWhat still shifts when copied
A1Nothing — fully relativeBoth column and row
$A1Column onlyRow only
A$1Row onlyColumn only
$A$1Both column and row — fully absoluteNothing

Mixed references earn their keep in a two-directional grid — for example, a multiplication table where row 1 holds the numbers 1–12 across the top and column A holds the numbers 1–12 down the side. A single formula typed once in B2 as =$A2*B$1 (column locked on the row-header reference, row locked on the column-header reference) can be filled both right and down to complete the entire grid correctly, because each dollar sign locks only the one part of its own reference that must never change as the formula spreads in that direction.

F4: Cycling Through Reference Types Without Retyping

You don't need to type dollar signs by hand every time. With your cursor positioned inside a reference in the formula bar (or right after typing one), pressing F4 cycles through all four forms in order:

A1 → press F4 → $A$1 → press F4 → A$1 → press F4 → $A1 → press F4 → A1 (back to the start)
A quick way to decide which reference type you need
Ask yourself: "if I copy this formula down or across, should this specific reference move with it, or stay put?" If the answer is "stay put," lock it. If the reference points at a single fixed input used by many formulas — a tax rate, an exchange rate, a discount percentage, a constant used throughout a sheet — that's almost always a sign it needs to be $-locked.
A reference bug produces a wrong number, not an error message
Unlike a typo in a function name (which Excel visibly flags), an un-locked reference that should have been locked produces a completely valid, error-free formula that simply calculates the wrong thing — often silently, and often not noticed until the totals genuinely don't add up. When a dragged-down formula's results look suspicious, checking whether every reference has the $ locking it actually needs is one of the first things worth doing.

Hands-On Exercises

Exercise 1

Set up a worksheet with a discount rate of 0.1 (10%) in cell D1, and prices 20, 40, 60 in A2:A4. In B2, write a formula that calculates each price's discount amount (price × rate), using the correct reference type so it can be filled down to B3 and B4 without breaking. Write out exactly what ends up in B3 and B4.

📄 View solution
Exercise 2

Cell C5 contains the formula =$A5*B$2. If this formula is copied to cell D6, what does the new formula in D6 look like? Explain which part of each reference changed and which part stayed fixed, and why.

📄 View solution
Exercise 3

Build a 5×5 multiplication table: the numbers 1–5 across B1:F1, and 1–5 down A2:A6. In cell B2, write a single formula using mixed references that can be filled right across to F2 and then down to row 6, correctly producing every product in the grid. Explain why each dollar sign is placed where it is.

📄 View solution

Chapter 3 Quick Reference

  • Relative (A1): both column and row shift when copied — the default
  • Absolute ($A$1): nothing shifts — always points at the exact same cell
  • Mixed ($A1 / A$1): only the un-locked part shifts — useful for two-directional fills like a multiplication table
  • F4 cycles a reference through all four forms without retyping
  • A missing $ lock produces a wrong number silently — no error is ever raised
  • Rule of thumb: a single fixed input reused by many rows (a rate, a constant) almost always needs $ locking