Before September 2020, Excel formulas had no memory.
Every time you needed the same value in two places inside a formula, you wrote the expression twice. Every time you needed it three places, you wrote it three times. This wasn't a minor inconvenience - it was the reason complex Excel formulas are unreadable. Not because the logic is complicated, but because there was no way to say "call this thing a name" and reuse it. Every formula was a tangle of repetition, and the only way out was helper columns or the Name Manager.
LET changed that. It gave formulas memory.
The mental model
Think of LET the same way you'd think about jotting down intermediate steps on a notepad before doing a calculation. Instead of holding everything in your head, you write down partial results, label them, and refer to those labels as you work through the problem.
That's exactly what LET does inside a formula. You declare names and bind values to them. Those names exist for the lifetime of that formula, and you can use them as many times as you like in the final calculation.
The structure is:
=LET( name1, value1, name2, value2, final_calculation_using_those_names )
The last argument is always the result - the thing the cell actually displays. Everything before it is your notepad.
What this looks like on a real problem
Here's a formula that's doing three things but looks like it's doing one incomprehensible thing:
=IF(ISNUMBER(XLOOKUP(A2,Sheet2!$A:$A,Sheet2!$B:$B)),XLOOKUP(A2,Sheet2!$A:$A,Sheet2!$B:$B)*IF(XLOOKUP(A2,Sheet2!$A:$A,Sheet2!$C:$C)="VIP",0.85,1),0)
That same XLOOKUP is written twice. A third XLOOKUP for the customer tier is buried inside the second one. Good luck explaining this to anyone. Good luck explaining it to yourself in three months.
Here's the same formula with LET:
=LET( price, XLOOKUP(A2,Sheet2!$A:$A,Sheet2!$B:$B), tier, XLOOKUP(A2,Sheet2!$A:$A,Sheet2!$C:$C), discount, IF(tier="VIP", 0.85, 1), IF(ISNUMBER(price), price * discount, 0) )
Same result. But now the formula reads like a sentence: look up the price, look up the tier, calculate the discount, apply it if a price exists. Each lookup runs exactly once. The logic is visible.
The performance thing nobody talks about
Excel evaluates every expression in a formula every time the sheet recalculates. If you write the same XLOOKUP twice, Excel runs it twice. In a small workbook this doesn't matter. In a sheet with ten thousand rows and complex lookups, it does.
LET evaluates each name-value expression once and reuses the cached result. If your formula uses XLOOKUP or FILTER or SORT in three places, you've just turned three evaluations into one. This is why LET formulas often feel snappier than the equivalent formula written the old way - not because of any special optimisation, but simply because Excel isn't doing duplicate work.
Where it breaks down
Two things to watch for. First: names in LET must be defined before they're used. You can reference price in the definition of discount, but you can't reference discount in the definition of price. The declarations run top to bottom, and forward references don't work.
Second: if you're sharing workbooks with people on older Excel versions, LET requires Microsoft 365 (released September 2020) or Excel 2024. Anyone opening the file in Excel 2016 or 2019 will see a #NAME? error. If cross-version compatibility matters, stick to the old approach or use helper columns - they're ugly but they're universal.
The shift in how you build formulas
The real change LET makes isn't performance or readability on its own. It's that it changes how you design formulas.
Before LET, you built from the inside out. You nested functions inside functions and hoped the logic held together. With LET, you can build from the outside in - start by naming the things you need, write the final calculation last, and fill in the definitions as you go. It's the difference between untangling a knot and tying a knot you designed from the start.
Once you start writing formulas this way, going back feels like writing without spaces between words. It still works, technically. It's just unnecessarily hard to read.