Excel LET Function: Cleaner Financial Formulas in 2026

May 21, 2026 · VeloraAI Team
Formulas Excel Financial Modeling

The average WACC formula in a banker's DCF model is 127 characters long, references the same cell five times, and is impossible to debug at 11pm before a pitch. The Excel LET function fixes that. Released to all Excel 365 users in 2021 and now standard in Excel 2024, the LET function lets you assign names to intermediate calculations inside a single formula — turning unreadable nested chains into something that looks like real code. For financial analysts who live in mile-long IF/INDEX/MATCH formulas, LET isn't a nice-to-have. It's the difference between a model your team can audit and one that gets re-built from scratch every quarter.

This guide walks through what LET does, when to use it, and seven copy-paste examples for WACC, free cash flow, tax calculations, IRR, and waterfall distributions.

What Is the Excel LET Function?

The Excel LET function assigns names to values and calculations inside a single formula, letting you define a variable once and reuse it without re-typing the underlying expression. The result is a formula that reads top-to-bottom like a mini-program — easier to write, audit, and modify — without creating helper cells or named ranges in the workbook.

LET is available in Excel 365, Excel 2021, Excel 2024, and Excel for the Web. It does not work in Excel 2019 or earlier.

LET Syntax in 30 Seconds

=LET(name1, value1, [name2, value2, ...], calculation)

The pattern is always name → value → name → value → … → final calculation. The last argument is the expression that gets returned. Variable names must start with a letter, contain no spaces, and cannot match existing Excel function names.

ℹ️ Note: LET variables are scoped to the formula they live in. They do not appear in the Name Manager and they do not persist outside the cell — which is exactly why they're safer than named ranges in shared models.

Why Should Financial Analysts Care About LET?

Three reasons LET matters more in finance than in any other Excel discipline:

  1. Audit-ability. Senior bankers, PE analysts, and FP&A leads spend more time reviewing models than building them. A LET-formatted formula tells the reviewer what each piece means, not just what it computes.
  2. Performance. When a value is referenced multiple times in a formula, LET evaluates it once and reuses the result. For volatile functions like OFFSET, INDIRECT, or RAND, this can cut recalculation time meaningfully.
  3. Hand-off resilience. Models change hands every promotion cycle. A LET-structured WACC formula survives the transition; a 200-character nested mess does not.

💡 Pro Tip: Treat every formula longer than 80 characters as a candidate for LET. If you reference the same cell or sub-calculation more than twice, LET it.

How Do You Use the LET Function in Excel?

To use LET in Excel, type =LET(, then alternate variable names and their values, and end with the final calculation that combines them. For example, =LET(rev, A1, growth, 0.15, rev*(1+growth)) assigns cell A1 to rev, defines a 15% growth rate, and returns the grown revenue. You can chain dozens of variables; the last argument is always the output.

Here's the readable-vs-nested comparison every analyst needs to see at least once:

// Without LET — what most models look like today
=((B2*C2)-(B2*C2*D2))/(1-D2)*(1+E2)

// With LET — same math, instantly understandable
=LET(
    revenue, B2*C2,
    tax_rate, D2,
    growth, E2,
    after_tax, (revenue - revenue*tax_rate)/(1-tax_rate),
    after_tax*(1+growth)
)

Both formulas return the same number. Only the second one survives a Monday-morning audit.

7 Financial Modeling Examples Using LET

The examples below are drawn from production models — DCF, leveraged finance, FP&A, and waterfall work. Copy them, swap the cell references, and ship.

1. WACC With Inline Tax-Shielded Cost of Debt

The classic WACC formula references the same equity-weight and debt-weight values four to six times. LET kills the duplication.

=LET(
    E, B2,                          // Market value of equity
    D, B3,                          // Market value of debt
    V, E + D,                       // Total capital
    Re, B4,                         // Cost of equity
    Rd, B5,                         // Pre-tax cost of debt
    t, B6,                          // Marginal tax rate
    (E/V)*Re + (D/V)*Rd*(1-t)
)

The reviewer sees the standard WACC equation laid out the way it appears in a textbook. The original nested version did not. For the full WACC build in Excel — covering CAPM, after-tax cost of debt, and sensitivity tables — see our WACC calculation guide.

2. Unlevered Free Cash Flow in a DCF

Building FCF from EBIT inside one cell — useful when you need a quick valuation sandbox without burning rows on the model.

=LET(
    EBIT, B10,
    tax_rate, $B$6,
    NOPAT, EBIT*(1-tax_rate),
    DA, B11,
    capex, B12,
    nwc_change, B13,
    NOPAT + DA - capex - nwc_change
)

Example: With EBIT of $120M, tax rate 25%, D&A of $18M, CapEx of $30M, and a $5M increase in net working capital, this LET formula returns $73M of unlevered FCF in a single cell — and the next analyst can read why.

3. Progressive Tax Calculation

US federal tax brackets are the textbook case for nested IFs. LET turns the chain into a stepwise lookup.

=LET(
    income, B2,
    b1, MIN(income, 11600)*0.10,
    b2, MAX(0, MIN(income, 47150) - 11600)*0.12,
    b3, MAX(0, MIN(income, 100525) - 47150)*0.22,
    b4, MAX(0, MIN(income, 191950) - 100525)*0.24,
    b5, MAX(0, income - 191950)*0.32,
    b1 + b2 + b3 + b4 + b5
)

This replaces a 9-level nested IF. Each bracket is independently auditable.

4. PE Waterfall: 8% Preferred Return Tier

Preferred return calculations inside a waterfall are where models go to die. LET makes the GP catch-up math survivable.

=LET(
    contrib, B5,                    // LP capital contributed
    yrs, B6,                        // Years invested
    pref_rate, 0.08,
    pref_target, contrib*((1+pref_rate)^yrs) - contrib,
    actual_dist, B7,
    paid_pref, MIN(actual_dist, pref_target),
    remaining, actual_dist - paid_pref,
    paid_pref
)

⚠️ Warning: LET formulas with more than 15-20 variables become hard to scan. For full four-tier waterfalls, break each tier into its own cell or move to LAMBDA so the logic is reusable across deals.

5. Loan Payment With a Balloon

PMT alone does not handle balloon payments. LET handles them with no helper cells.

=LET(
    principal, B2,
    rate, B3/12,
    term_months, B4,
    balloon, B5,
    pv_balloon, balloon/((1+rate)^term_months),
    amort_principal, principal - pv_balloon,
    PMT(rate, term_months, -amort_principal)
)

Useful for commercial real estate underwriting where balloons at year 5 or 10 are standard.

6. CAGR With Date-Aware Period Count

Standard CAGR formulas assume integer years. LET combines with YEARFRAC to handle real-world deal timelines.

=LET(
    start_val, B2,
    end_val, B3,
    start_date, B4,
    end_date, B5,
    years, YEARFRAC(start_date, end_date, 1),
    (end_val/start_val)^(1/years) - 1
)

The 1 in YEARFRAC uses the actual/actual day count convention — the standard for corporate finance.

7. Variance Analysis With Favorability Flag

Pairing LET with a final IF gives you a self-explaining variance cell that even non-finance partners can read.

=LET(
    actual, B2,
    budget, C2,
    variance, actual - budget,
    pct_var, variance/budget,
    flag, IF(variance >= 0, "Favorable", "Unfavorable"),
    flag & " by " & TEXT(ABS(pct_var), "0.0%")
)

Returns strings like "Favorable by 12.3%" or "Unfavorable by 4.7%" — perfect for board-deck commentary cells.

LET vs LAMBDA: Which One Should You Use?

LET defines variables inside a single formula. LAMBDA defines a reusable function you can call across the workbook. They're complementary, not competing.

Feature LET LAMBDA
Scope One formula cell Entire workbook
Reusability None — re-write per cell Define once, call by name
Arguments No — values only Yes — accepts inputs
Best for One-off complex formulas Standardized calculations (WACC, FCF)
Where defined Inside the cell Name Manager
Excel version 365 / 2021+ 365 / 2021+

The decision rule: use LET when the formula appears in one place. Promote it to LAMBDA the moment you copy-paste it for the second time. For a complete guide to building reusable LAMBDA functions for WACC, free cash flow, and other repeating finance calculations, see our Excel LAMBDA custom functions guide.

graph TD
    A[Complex Formula Needed] --> B{Used in more<br/>than 2 cells?}
    B -->|No| C[Use LET<br/>Inline variables]
    B -->|Yes| D{Same logic across<br/>multiple models?}
    D -->|No| E[Use LAMBDA<br/>Workbook-scoped]
    D -->|Yes| F[Use LAMBDA in a<br/>shared function library]
    C --> G[Cleaner audit trail]
    E --> G
    F --> G

How Do You Debug an Excel LET Formula?

To debug a LET formula, temporarily replace the final calculation with one of the named variables to inspect its value, then walk through each name in order. For multi-line LET formulas, use Alt+Enter to break each variable onto its own line so the Formula Bar shows the logic vertically. The F9 key still works on selected segments inside a LET.

The Three-Step LET Debug Workflow

  1. Isolate. Replace the final argument with the name of the first variable. Confirm it returns what you expect.
  2. Walk forward. Step through each subsequent variable by replacing the final argument with that name.
  3. Recompose. Once every variable returns its expected value, restore the final calculation.

💡 Pro Tip: Format every multi-variable LET formula on separate lines using Alt+Enter. Excel ignores the line breaks during calculation but the Formula Bar becomes a readable code editor.

Common LET Mistakes Financial Analysts Make

After auditing dozens of LET-heavy models, the same five errors come up repeatedly:

  • Reserved-word collisions. Don't name a variable IF, SUM, PV, or any existing function. Excel returns #NAME?.
  • Missing the final calculation. Every LET must end with an output expression, not a variable assignment. =LET(x, 5) errors; =LET(x, 5, x) does not.
  • Single-use variables. If a value is only referenced once, LET adds noise instead of clarity. Reserve LET for values used 2+ times or for genuinely complex chains.
  • Treating LET as a substitute for the Name Manager. Cross-formula constants (tax rate, discount rate) still belong in named ranges or an Assumptions sheet — not buried inside every LET.
  • Over-nesting LET inside LET. Nesting works but kills readability fast. If you find yourself nesting, that's the signal to refactor into LAMBDA.

Combining LET With Modern Excel Functions

LET shines when paired with the dynamic array family. Three combinations every analyst should know:

LET + FILTER for Auditable Cohort Analysis

=LET(
    data, A2:E1000,
    region, "EMEA",
    threshold, 1000000,
    filtered, FILTER(data, (B2:B1000=region)*(D2:D1000>=threshold)),
    SUM(CHOOSECOLS(filtered, 4))
)

Pulls EMEA deals over $1M and sums their revenue column — no helper sheet required. For teams building multi-dimensional P&L and variance summaries that need interactive slicer filtering without formulas, the Excel pivot tables for financial reporting guide shows the complementary row/column reshaping approach.

LET + XLOOKUP for Multi-Step Lookups

=LET(
    ticker, B2,
    price, XLOOKUP(ticker, prices[Ticker], prices[Close]),
    shares, XLOOKUP(ticker, holdings[Ticker], holdings[Shares]),
    weight, XLOOKUP(ticker, weights[Ticker], weights[%]),
    price*shares*weight
)

Three lookups, one cell, fully readable. For more advanced XLOOKUP patterns — including approximate match, dynamic spills, and multi-column returns across financial data — see our XLOOKUP for financial analysis guide.

LET + SEQUENCE for Inline Amortization

=LET(
    principal, 1000000,
    rate, 0.05/12,
    term, 60,
    period, SEQUENCE(term),
    payment, PMT(rate, term, -principal),
    balance, principal*((1+rate)^period) - payment*(((1+rate)^period - 1)/rate),
    balance
)

Spills the full amortization schedule from a single cell. No table required.

ℹ️ Note: Spilled LET formulas require Excel 365 or 2024. The dynamic array spill behavior is what makes one-cell amortization possible.

Frequently Asked Questions

Is the Excel LET function available in Excel 2019?

No. LET was released in 2020 to Microsoft 365 subscribers and is included in Excel 2021, Excel 2024, and Excel for the Web. Excel 2019 and earlier desktop versions do not support LET. If you share models with users on Excel 2019, your LET formulas will return #NAME? errors on their machines.

Does LET make Excel formulas faster?

Yes, in cases where you reference the same expression more than once. LET evaluates each named value only once, even if it's used 10 times in the final calculation. The performance gain is significant for volatile functions (OFFSET, INDIRECT, RAND, NOW) and for expensive lookups in large datasets. For simple formulas with no repeated expressions, LET has no performance impact.

What's the difference between LET and named ranges?

A named range is workbook-scoped and visible in the Name Manager. It can be referenced from any cell. A LET variable is formula-scoped, invisible outside the cell, and cannot be referenced elsewhere. Use named ranges for global constants like tax rates and discount rates. Use LET for intermediate calculations inside a single complex formula.

Can you use LET inside an array formula?

Yes. LET works seamlessly with dynamic arrays, FILTER, SORT, UNIQUE, SEQUENCE, and any spilled range. In fact, LET is one of the cleanest ways to handle multi-step array logic in a single cell — define your intermediate arrays as named variables and combine them at the end.

How many variables can LET handle?

Up to 126 name/value pairs in a single LET, per Microsoft's documentation. In practice, anything beyond 10-15 variables becomes unreadable. If you're approaching that limit, the formula belongs in LAMBDA or split across helper cells.

The Bottom Line

For a complete how-to on using LET in three-statement and LBO models — including step-by-step refactoring of legacy formulas, nesting patterns, and LET vs LAMBDA decision rules — see our LET function guide for financial models.

The Excel LET function is the single highest-leverage change you can make to a financial model without rebuilding it. It costs nothing, requires no add-ins, and immediately makes your formulas readable to the next analyst — which is the same as making them auditable to your MD. Start by LET-ifying your WACC, free cash flow, and any IF chain longer than three levels. The improvement is permanent.

If you spend more time fighting formulas than analyzing the business, that's exactly the problem VeloraAI is built to solve — natural-language formula generation, automated audits, and LET-ready output that drops straight into your model. For a practical guide to generating LET-structured financial formulas from plain-English descriptions — including WACC, FCF, and waterfall formulas — see our AI Excel formula generator guide.

Next step: open your most-edited model, find the longest formula, and rewrite it with LET. You'll feel the difference on the first audit pass.