Excel Formulas

Excel Formulas

Working, copy-ready solutions to real Excel tasks — each with a step-by-step explanation, an interactive demo you can try right here, and a free practice workbook.

These are formula recipes: how to actually do something — sum by month, look up across two criteria, count unique values. Looking for what a single function does instead? Browse the companion Excel Functions library (500+ guides). Every recipe below links to the function references it uses.


Lookup (35)Sum (16)Count (15)Average (11)Min & Max (5)Logical (16)Information (13)Text (41)Date & Time (42)Dynamic Arrays (27)Math (22)Rank (1)Percentage (2)Round (10)Financial (31)Business (25)Charts (12)Analysis (12)Statistics (30)Advanced (12)Conditional Formatting (30)Data Validation (5)HR & Payroll (14)Real Estate (12)Retail & Inventory (12)Restaurant & Hospitality (12)Education & Grading (12)Construction & Trades (12)Healthcare & Medical (12)Nonprofit & Fundraising (12)Freelance & Agency (12)Sales & CRM (13)E-commerce & Marketing (13)Fitness & Gym (13)Automotive & Fleet (12)Events & Catering (12)Data Cleaning (17)Dashboards & Reporting (14)Auditing & Error-Proofing (15)Manufacturing & Operations (12)Legal & Billing (12)Agriculture & Farming (12)Salon, Spa & Beauty (12)Photography & Creative (13)Property Management (12)Insurance (12)Logistics & Trucking (13)Veterinary & Pet Care (12)Childcare & Daycare (13)Dental Practice (12)Cleaning & Janitorial (12)Landscaping & Lawn Care (12)Pool & Spa Service (12)HVAC & Field Service (12)Food Truck & Brewery (12)Barber & Tattoo Studio (8)Coffee Shop & Cafe (5)Auto Repair Shop (5)Bakery (7)Print Shop (6)Moving & Storage (4)Pest Control (5)Solar (6)Towing & Recovery (4)Car Wash & Detailing (4)Pressure Washing (4)Locksmith (5)Roofing (3)Junk Removal (5)Vending (5)Appliance Repair (5)Window Cleaning (4)Tutoring & Test Prep (3)Dog Walking (3)Handyman (3)Pet Grooming (3)Plumbing (4)Electrician (4)Tree Service (4)Laundromat (4)Sign Shop (4)Chimney Sweep (2)Gutter Cleaning (2)Fencing (2)Carpet Cleaning (3)Courier & Delivery (2)Equipment Rental (3)Flooring (2)Painting (2)Septic Service (2)Garage Door (2)Auto Glass (2)Welding & Fabrication (2)Mobile Notary (3)Blinds & Shades (2)Upholstery (2)Masonry (2)Powder Coating (2)Holiday Lighting (2)Boat Detailing (2)Window Tint (3)Tailoring & Alterations (2)Screen Printing (3)Bounce House Rental (2)Knife Sharpening (2)Portable Toilet Rental (2)Escape Room (3)Embroidery (2)Photo Booth Rental (3)DJ Services (2)Mobile Bartending (2)Balloon Decor (2)Axe Throwing (3)Mini Golf (2)Snow Cone & Shaved Ice (2)Face Painting (2)Pet Waste Removal (2)Spray Tanning (2)Valet Parking (2)Tent & Canopy Rental (2)Limo & Party Bus (2)Paintball Field (2)Rock Climbing Gym (2)Florist (2)Bike Shop (2)Trampoline Park (2)Butcher Shop (2)Bowling Alley (2)Laser Tag (2)Go-Kart Track (2)Batting Cages (2)Kayak & Canoe Rental (2)Charter Fishing (2)Campground & RV Park (2)Dance Studio (2)Martial Arts Dojo (2)Music Lessons (2)Swim School (2)Christmas Tree Farm (2)Winery & Vineyard (2)Marina & Boat Slip (2)Pottery Studio (2)Horse Stable & Boarding (2)Wedding Venue (2)Arcade & Family Entertainment (2)Roller Skating Rink (2)Ice Rink (2)Golf Course & Driving Range (2)Ski & Snowboard Rental (2)Pickleball & Tennis Club (2)Dry Cleaner (2)Shoe Repair (2)Jewelry & Watch Repair (2)Beekeeping & Apiary (2)Orchard & U-Pick Farm (2)Greenhouse & Plant Nursery (2)Scuba Dive Shop (2)Shooting & Archery Range (2)Drive-In Theater (2)Hotel & Motel (2)Yoga Studio (2)Car Rental (2)Massage Therapy (2)Farmers Market Vendor (2)Vacation Rental (2)

Lookup

Find a value by another value — across rows, columns, tiers, or multiple keys.

Build clickable web, email, file, or in-workbook links with HYPERLINK.

=HYPERLINK("https://dfwexcel.com", "Visit site")
Recipe, demo & practice file →

Turn text into a live cell or sheet reference with INDIRECT.

=INDIRECT(D1 & D2)
Recipe, demo & practice file →

Chain two lookups: result of one feeds the next.

=VLOOKUP(VLOOKUP(A2, empTable, 2, 0), deptTable, 2, 0)
Recipe, demo & practice file →

Do a case-sensitive lookup with EXACT and INDEX/MATCH.

=INDEX(C2:C8, MATCH(TRUE, EXACT(A2:A8, E2), 0))
Recipe, demo & practice file →

Make a named range that auto-grows with OFFSET + COUNTA.

=OFFSET($B$2, 0, 0, COUNTA($B$2:$B$1000), 1)
Recipe, demo & practice file →

Find the closest numeric value with INDEX/MATCH + MIN/ABS.

=INDEX(items, MATCH(MIN(ABS(values-E2)), ABS(values-E2), 0))
Recipe, demo & practice file →

Return the label of the highest (or lowest) value.

=INDEX(names, MATCH(MAX(scores), scores, 0))
Recipe, demo & practice file →

Flip rows and columns with the live TRANSPOSE function.

=TRANSPOSE(A1:C2)
Recipe, demo & practice file →

Convert a column number to its letter with ADDRESS + SUBSTITUTE.

=SUBSTITUTE(ADDRESS(1, A2, 4), "1", "")
Recipe, demo & practice file →

Show the current tab name in a cell with CELL and TEXTAFTER.

=TEXTAFTER(CELL("filename", A1), "]")
Recipe, demo & practice file →

Return the first or last non-blank value with the LOOKUP trick or XLOOKUP.

=LOOKUP(2, 1/(A2:A100<>""), A2:A100)
Recipe, demo & practice file →

Return the most recent (last) match with XLOOKUP search_mode -1 or the LOOKUP trick.

=XLOOKUP(E2, A2:A8, C2:C8, , 0, -1)
Recipe, demo & practice file →

Look up across a header row and return a value below with HLOOKUP.

=HLOOKUP(E2, A1:D3, 3, FALSE)
Recipe, demo & practice file →

List every tab in the workbook with a GET.WORKBOOK named formula.

=GET.WORKBOOK(1) & T(NOW())
Recipe, demo & practice file →

Look up across several sheets by chaining IFERROR.

=IFERROR(VLOOKUP(A2, Sheet1!T, 2, 0), IFERROR(VLOOKUP(A2, Sheet2!T, 2, 0), VLOOKUP(A2, Sheet3!T, 2, 0)))
Recipe, demo & practice file →

Look up a whole column of values in one spilling formula.

=XLOOKUP(E2:E100, ids, names)
Recipe, demo & practice file →

Look up data on another sheet, optionally chosen with INDIRECT.

=VLOOKUP(E2, Products!A:B, 2, FALSE)
Recipe, demo & practice file →

Look up a value to the left with INDEX/MATCH.

=INDEX(A:A, MATCH(E2, C:C, 0))
Recipe, demo & practice file →

Return several columns from one lookup that spills the whole record.

=XLOOKUP(E2, A2:A8, B2:D8)
Recipe, demo & practice file →

Return the 2nd, 3rd, or nth match with FILTER+INDEX or INDEX/SMALL.

=INDEX(FILTER(C2:C9, A2:A9=E2), 2)
Recipe, demo & practice file →

Look up a value on two or more keys at once by joining them inside XLOOKUP or INDEX/MATCH.

=XLOOKUP(G2&"|"&G3, A2:A8&"|"&B2:B8, C2:C8)
Recipe, demo & practice file →

Partial-match lookup with * and ? wildcards.

=VLOOKUP("*"&E2&"*", table, 2, FALSE)
Recipe, demo & practice file →

ISNA wrapped around MATCH checks whether a typed code exists in the reference list BEFORE any downstream lookup formula runs against it, catching a typo at the point of entry instead of chasing a #N/A three formulas later.

=IF(ISNA(MATCH(Code,CodeList,0)),"Not found — check the code","OK")
Recipe, demo & practice file →

Merge two tables by a key (a formula join).

=VLOOKUP(A2, products, 2, FALSE)
Recipe, demo & practice file →

Look up on a fragment using wildcards with VLOOKUP or XLOOKUP.

=VLOOKUP("*"&E2&"*", A2:B8, 2, FALSE)
Recipe, demo & practice file →

Sum or average the last N rows with a moving OFFSET window.

=SUM(OFFSET(B1, COUNT(B:B), 0, -E1, 1))
Recipe, demo & practice file →

Land a number in the right tier or tax bracket with XLOOKUP match_mode -1 — no nested IFs.

=XLOOKUP(D2, A2:A5, B2:B5, , -1)
Recipe, demo & practice file →

Look up by row and column label with INDEX and two MATCHes.

=INDEX(B2:E10, MATCH(H2, A2:A10, 0), MATCH(H3, B1:E1, 0))
Recipe, demo & practice file →

Land in the right band on both axes of a rate grid with INDEX/MATCH.

=INDEX(rates, MATCH(V1, rowBreaks, 1), MATCH(V2, colBreaks, 1))
Recipe, demo & practice file →

Pull the value where a row and a column meet, with nested XLOOKUP or INDEX/MATCH/MATCH.

=XLOOKUP(H2, A2:A6, XLOOKUP(H3, B1:D1, B2:D6))
Recipe, demo & practice file →

Look up a value by both a row label and a column label at once.

=INDEX(data,MATCH(row,rows,0),MATCH(col,cols,0))
Recipe, demo & practice file →

Two-way lookup with nested XLOOKUP (row x column).

=XLOOKUP(G1, rowLabels, XLOOKUP(G2, colLabels, dataGrid))
Recipe, demo & practice file →

Find the nearest tier with XLOOKUP match mode.

=XLOOKUP(A2, thresholds, rates, , -1)
Recipe, demo & practice file →

Return a default instead of #N/A with XLOOKUP.

=XLOOKUP(A2, ids, names, "Not found")
Recipe, demo & practice file →

Find the last (most recent) match with XLOOKUP search mode.

=XLOOKUP(A2, ids, values, , 0, -1)
Recipe, demo & practice file →

Sum

Add things up by category, period, or condition.

Build a cumulative running total with one anchored, expanding-range SUM (or SCAN).

=SUM($B$2:B2)
Recipe, demo & practice file →

Running total that resets for each group with SUMIFS.

=SUMIFS($B$2:B2, $A$2:A2, A2)
Recipe, demo & practice file →

Sum rows whose label contains a word with SUMIF wildcards.

=SUMIF(labels, "*north*", amounts)
Recipe, demo & practice file →

Total a column on two or more conditions at once with SUMIFS (AND logic).

=SUMIFS(D2:D8, B2:B8, "West", C2:C8, "Widget")
Recipe, demo & practice file →

Sum Every Nth Row

All versions

Add every Nth row with SUMPRODUCT and MOD on the row number.

=SUMPRODUCT((MOD(ROW(B2:B13)-ROW(B2), 3)=0) * B2:B13)
Recipe, demo & practice file →

Sum only filtered/visible rows with SUBTOTAL (or AGGREGATE).

=SUBTOTAL(109, B2:B100)
Recipe, demo & practice file →

Sum amounts that fall on weekdays or weekends.

=SUMPRODUCT((WEEKDAY(dates, 2) <= 5) * amounts)
Recipe, demo & practice file →

Sum a range that has errors using AGGREGATE.

=AGGREGATE(9, 6, B2:B100)
Recipe, demo & practice file →

Sum by Month

Excel 365

Total values that fall in a given month with SUMIFS and EOMONTH — year-safe, no helper column.

=SUMIFS(B:B, A:A, ">="&E2, A:A, "<="&EOMONTH(E2,0))
Recipe, demo & practice file →

Sum by Quarter

All versions

Total amounts for a quarter with SUMIFS and EOMONTH date boundaries.

=SUMIFS(B:B, A:A, ">="&E2, A:A, "<="&EOMONTH(E2,2))
Recipe, demo & practice file →

Total rows whose label contains text using SUMIF with wildcards.

=SUMIF(A2:A8, "*Pro*", B2:B8)
Recipe, demo & practice file →

Sum magnitudes ignoring sign with SUMPRODUCT + ABS.

=SUMPRODUCT(ABS(B2:B100))
Recipe, demo & practice file →

Add the same cell across many sheets with a 3D reference.

=SUM(Jan:Dec!B2)
Recipe, demo & practice file →

Total just the largest few values with LARGE and SUMPRODUCT — top 3, top 5, or N from a cell.

=SUMPRODUCT(LARGE(B2:B8, {1,2,3}))
Recipe, demo & practice file →

Sum where a field is one value OR another.

=SUM(SUMIF(region, {"East","West"}, amount))
Recipe, demo & practice file →

Build a region-by-month matrix report with one SUMIFS filled across and down.

=SUMIFS(amount, region, $A2, month, B$1)
Recipe, demo & practice file →

Count

Count rows, distinct values, and matches.

Count rows that meet several conditions at once with COUNTIFS.

=COUNTIFS(B2:B8, "West", D2:D8, ">=100")
Recipe, demo & practice file →

Count empty cells in a range with COUNTBLANK.

=COUNTBLANK(A2:A10)
Recipe, demo & practice file →

Count cells containing a word or fragment with COUNTIF and wildcards.

=COUNTIF(A2:A8, "*Pro*")
Recipe, demo & practice file →

Count text, numbers, non-blank or blank cells with the right COUNT function.

=COUNTIF(A2:A8, "*")
Recipe, demo & practice file →

Count dates that fall between two dates with COUNTIFS.

=COUNTIFS(A2:A10, ">="&E1, A2:A10, "<="&E2)
Recipe, demo & practice file →

Count how many dates fall on a weekday with SUMPRODUCT and WEEKDAY.

=SUMPRODUCT(--(WEEKDAY(A2:A10) = 2))
Recipe, demo & practice file →

Count distinct values that meet a condition.

=SUMPRODUCT((region="East")/COUNTIFS(name, name, region, "East", region, "East"))
Recipe, demo & practice file →

Count numbers, non-blanks, and blanks separately.

=COUNT(A2:A100) // numbers only =COUNTA(A2:A100) // non-blank (any type) =COUNTBLANK(A2:A100) // empty cells
Recipe, demo & practice file →

Count rows matching any of several conditions.

=SUMPRODUCT(SIGN((status="Open") + (priority="High")))
Recipe, demo & practice file →

Count how many distinct entries are in a list — COUNTA(UNIQUE()) or the classic SUMPRODUCT trick.

=COUNTA(UNIQUE(A2:A10))
Recipe, demo & practice file →

Count values above (or below) the average.

=COUNTIF(B2:B100, ">"&AVERAGE(B2:B100))
Recipe, demo & practice file →

Count values between a low and high bound with COUNTIFS.

=COUNTIFS(B2:B100, ">=70", B2:B100, "<=89")
Recipe, demo & practice file →

Count distinct values within each group with UNIQUE+FILTER or SUMPRODUCT.

=COUNTA(UNIQUE(FILTER(B2:B100, A2:A100=E2)))
Recipe, demo & practice file →

Group numbers into bands and count each with FREQUENCY or COUNTIFS.

=FREQUENCY(data, bins)
Recipe, demo & practice file →

Number each occurrence of a value with an expanding COUNTIF.

=COUNTIF($A$2:A2, A2)
Recipe, demo & practice file →

Average

Mean values by group, weighted, or filtered.

Average a range but skip exact zeros with AVERAGEIF and a <>0 criterion — blanks are already ignored.

=AVERAGEIF(B2:B100, "<>0")
Recipe, demo & practice file →

Average only filtered, visible rows with SUBTOTAL code 101 — updates live as you change the filter.

=SUBTOTAL(101, B2:B100)
Recipe, demo & practice file →

Average a column that contains errors with AGGREGATE option 6.

=AGGREGATE(1, 6, B2:B8)
Recipe, demo & practice file →

Average values for a given day of week with SUMPRODUCT and WEEKDAY — no helper column needed.

=SUMPRODUCT((WEEKDAY(dates)=2)*values) / SUMPRODUCT(--(WEEKDAY(dates)=2))
Recipe, demo & practice file →

Average by Group

All versions

Average the values in one category with AVERAGEIF / AVERAGEIFS.

=AVERAGEIF(B2:B8, E2, C2:C8)
Recipe, demo & practice file →

Average the most recent N values with OFFSET and COUNT (or TAKE in 365) — the window slides as data grows.

=AVERAGE(OFFSET(B1, COUNT(B:B)-N+1, 0, N, 1))
Recipe, demo & practice file →

Average only the best few values by nesting LARGE inside AVERAGE.

=AVERAGE(LARGE(B2:B8, {1,2,3}))
Recipe, demo & practice file →

Moving Average

All versions

Smooth a series with a rolling AVERAGE window that slides down the column.

=AVERAGE(B2:B4)
Recipe, demo & practice file →

Build a cumulative running average with AVERAGE and an expanding range — the mean of everything so far.

=AVERAGE($B$2:B2)
Recipe, demo & practice file →

Weighted Average

All versions

Weight some values more than others with SUMPRODUCT divided by total weight.

=SUMPRODUCT(B2:B5, C2:C5) / SUM(C2:C5)
Recipe, demo & practice file →

Weight recent points more with SUMPRODUCT — a responsive smoothed average divided by the weight total.

=SUMPRODUCT(values, weights) / SUM(weights)
Recipe, demo & practice file →

Min & Max

Largest and smallest values, with or without conditions.

Clamp a number between a floor and ceiling with nested MIN and MAX.

=MIN(MAX(A2, 0), 100)
Recipe, demo & practice file →

Get the 2nd, 3rd, or nth largest/smallest value with LARGE and SMALL.

=LARGE(B2:B8, 2)
Recipe, demo & practice file →

Find the biggest value in a given month with MAXIFS and date boundaries.

=MAXIFS(B:B, A:A, ">="&E2, A:A, "<="&EOMONTH(E2,0))
Recipe, demo & practice file →

Find the largest value that meets a condition with MAXIFS.

=MAXIFS(C2:C8, B2:B8, E2)
Recipe, demo & practice file →

Find the smallest value that meets a condition with MINIFS.

=MINIFS(C2:C8, B2:B8, E2)
Recipe, demo & practice file →

Logical

Decisions and tests — IF, IFS, and condition checks that label, grade, and flag.

Replace #N/A and #DIV/0! errors with a clean fallback using IFERROR / IFNA.

=IFERROR(VLOOKUP(E2, A:B, 2, 0), "")
Recipe, demo & practice file →

Compare numbers within a tolerance (floating point).

=ABS(A2 - B2) <= 0.01
Recipe, demo & practice file →

Turn scores into letter grades with IFS, nested IF, or a lookup table.

=IFS(B2>=90,"A", B2>=80,"B", B2>=70,"C", B2>=60,"D", TRUE,"F")
Recipe, demo & practice file →

Exclusive OR: TRUE when exactly one condition holds.

=XOR(A2, B2)
Recipe, demo & practice file →

Fill blank cells with the value above using IF or Go To Special.

=IF(A2="", B1, A2)
Recipe, demo & practice file →

Mark or highlight repeated values with COUNTIF — labels and conditional formatting.

=IF(COUNTIF($A$2:$A$8, A2)>1, "Duplicate", "")
Recipe, demo & practice file →

Flag rows meeting every condition with AND.

=IF(AND(B2>100, C2="In stock", D2<>"Hold"), "Ship", "")
Recipe, demo & practice file →

Grade or band values with the IFS function.

=IFS(A2>=90,"A", A2>=80,"B", A2>=70,"C", TRUE,"F")
Recipe, demo & practice file →

IF with AND / OR

All versions

Make an IF decision on several conditions at once by nesting AND or OR.

=IF(AND(B2>=50000, C2<=0.3), "Approve", "Review")
Recipe, demo & practice file →

Catch only #N/A (not all errors) with IFNA.

=IFNA(VLOOKUP(A2, table, 2, FALSE), "Not found")
Recipe, demo & practice file →

Choose between IFS, nested IF, and a lookup table.

IFS: =IFS(A2>=90,"A", A2>=80,"B", TRUE,"C") Nested: =IF(A2>=90,"A", IF(A2>=80,"B","C")) Table: =VLOOKUP(A2, bands, 2, TRUE)
Recipe, demo & practice file →

Map a value to a result with SWITCH instead of nested IFs.

=SWITCH(A2, 1, "New", 2, "Open", 3, "Closed", "Unknown")
Recipe, demo & practice file →

Show a default value when a cell is blank.

=IF(A2="", "N/A", A2)
Recipe, demo & practice file →

Convert TRUE/FALSE to 1/0 to count or sum.

=SUMPRODUCT(--(A2:A100>100))
Recipe, demo & practice file →

Turn TRUE/FALSE into Yes/No, Pass/Fail, or tick/cross.

=IF(A2>=70, "Yes", "No")
Recipe, demo & practice file →

Test several conditions in order without stacking IFs inside each other.

=IFS(score>=90,"A",score>=80,"B",TRUE,"F")
Recipe, demo & practice file →

Information

Test what's in a cell — text, errors, blanks, numbers.

Check that all required cells are filled.

=COUNTA(B2:F2) = COLUMNS(B2:F2)
Recipe, demo & practice file →

Test whether a cell contains text with ISNUMBER and SEARCH.

=ISNUMBER(SEARCH(B2, A2))
Recipe, demo & practice file →

Test whether a formula errored with ISERROR or ISNA.

=IF(ISERROR(A2/B2), "Check input", "OK")
Recipe, demo & practice file →

Test whether a cell is empty with ISBLANK inside IF.

=IF(ISBLANK(A2), "Missing", "OK")
Recipe, demo & practice file →

Tell real numbers from text-numbers with ISNUMBER and ISTEXT.

=ISNUMBER(A2)
Recipe, demo & practice file →

Count how many cells hold errors with SUMPRODUCT and ISERROR — audit a sheet in one formula.

=SUMPRODUCT(--ISERROR(B2:B100))
Recipe, demo & practice file →

Detect which cells contain formulas with ISFORMULA — audit a model or flag overwritten cells.

=ISFORMULA(A2)
Recipe, demo & practice file →

Branch on text vs numbers with ISNUMBER/ISTEXT.

=IF(ISNUMBER(A2), "Number: "&A2, IF(ISTEXT(A2), "Text", "Other"))
Recipe, demo & practice file →

Identify whether a value is a number, text, logical, or error with TYPE — branch logic on the kind.

=TYPE(A2)
Recipe, demo & practice file →

Read a cell's address, column, type or filename with the CELL function — metadata for dynamic labels.

=CELL("col", A2)
Recipe, demo & practice file →

Test whether a number is even or odd.

=ISEVEN(A2)
Recipe, demo & practice file →

Try several lookups in turn with nested IFERROR — the first hit wins, with a clean message if all miss.

=IFERROR(VLOOKUP(id,T1,2,0), IFERROR(VLOOKUP(id,T2,2,0), "Not found"))
Recipe, demo & practice file →

Turn #N/A into 0, blank, or a message with IFNA — without hiding genuine errors like IFERROR does.

=IFNA(VLOOKUP(id, table, 2, 0), 0)
Recipe, demo & practice file →

Text

Pull apart and reshape text — split, extract, clean, and join.

Capitalize names with PROPER, or force case with UPPER and LOWER.

=PROPER(A2)
Recipe, demo & practice file →

Strip extra spaces, line breaks and non-breaking spaces with TRIM, CLEAN and SUBSTITUTE.

=TRIM(CLEAN(A2))
Recipe, demo & practice file →

Turn numbers stored as text into real numbers with VALUE.

=VALUE(A2)
Recipe, demo & practice file →

Convert numbers stored as text back to real numbers with VALUE or a math nudge (*1, --) so they sum.

=VALUE(A2) // or =A2 * 1
Recipe, demo & practice file →

Count characters excluding spaces with LEN + SUBSTITUTE.

=LEN(SUBSTITUTE(A2, " ", ""))
Recipe, demo & practice file →

Count how many times a word appears in a cell.

=(LEN(A2) - LEN(SUBSTITUTE(LOWER(A2),"the",""))) / LEN("the")
Recipe, demo & practice file →

Count words in a cell by counting spaces with LEN and SUBSTITUTE.

=LEN(TRIM(A2)) - LEN(SUBSTITUTE(TRIM(A2), " ", "")) + 1
Recipe, demo & practice file →

Pull first and last names out of a full-name cell with TEXTBEFORE/AFTER or LEFT/RIGHT.

=TEXTBEFORE(A2, " ") // first name =TEXTAFTER(A2, " ") // last name
Recipe, demo & practice file →

Pull the number out of mixed text with TEXTAFTER/VALUE or MID/FIND.

=VALUE(TEXTAFTER(A2, "-"))
Recipe, demo & practice file →

Pull text between two characters with TEXTBEFORE/AFTER or MID/FIND.

=TEXTBEFORE(TEXTAFTER(A2, "("), ")")
Recipe, demo & practice file →

Extract text between parentheses with MID + FIND.

=MID(A2, FIND("(",A2)+1, FIND(")",A2)-FIND("(",A2)-1)
Recipe, demo & practice file →

Pull the domain (after @) from an email with TEXTAFTER or MID/FIND.

=TEXTAFTER(A2, "@")
Recipe, demo & practice file →

Pull the part after the last dot — even when the name has several dots.

=TEXTAFTER(A2,".",-1)
Recipe, demo & practice file →

Pull the first word from a cell with LEFT + FIND.

=LEFT(A2, FIND(" ", A2 & " ") - 1)
Recipe, demo & practice file →

Pull the last word with the TRIM/RIGHT/REPT trick.

=TRIM(RIGHT(SUBSTITUTE(A2, " ", REPT(" ", 100)), 100))
Recipe, demo & practice file →

Pull the nth word from a phrase with the SUBSTITUTE/REPT/MID trick.

=TRIM(MID(SUBSTITUTE(A2," ",REPT(" ",100)), (N-1)*100+1, 100))
Recipe, demo & practice file →

Get the value after a label like Name: with SEARCH.

=TRIM(MID(A2, SEARCH("Name:", A2) + LEN("Name:"), 100))
Recipe, demo & practice file →

Find and replace several things at once with nested SUBSTITUTE.

=SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(A2, "$", ""), ",", ""), " ", "")
Recipe, demo & practice file →

Swap text inside a formula with SUBSTITUTE or REPLACE.

=SUBSTITUTE(A2, "-", " ")
Recipe, demo & practice file →

Find the position of the nth occurrence of a character with FIND/SUBSTITUTE.

=FIND("~", SUBSTITUTE(A2, "-", "~", N))
Recipe, demo & practice file →

Find where text appears in a cell with SEARCH/FIND.

=SEARCH("@", A2)
Recipe, demo & practice file →

Build initials from a name with LEFT/MID or TEXTSPLIT.

=LEFT(A2,1) & MID(A2, FIND(" ",A2)+1, 1)
Recipe, demo & practice file →

Draw in-cell bar charts, stars, and progress bars with REPT.

=REPT("|", B2)
Recipe, demo & practice file →

Insert special characters and inspect codes with CHAR, CODE and UNICHAR.

=A2 & CHAR(10) & B2
Recipe, demo & practice file →

Combine a range of cells into one delimited string with TEXTJOIN — skips blanks.

=TEXTJOIN(", ", TRUE, A2:A6)
Recipe, demo & practice file →

Join an entire range of cells with TEXTJOIN or CONCAT.

=TEXTJOIN(", ", TRUE, A2:A6)
Recipe, demo & practice file →

Hide all but the last few characters with REPT and RIGHT.

=REPT("*", LEN(A2)-4) & RIGHT(A2, 4)
Recipe, demo & practice file →

Turn 1 into 1st, 22 into 22nd, 13 into 13th.

=A2 & IF(MOD(A2,100)>=11, IF(MOD(A2,100)<=13,"th",CHOOSE(MOD(A2,10)+1,"th","st","nd","rd","th","th","th","th","th","th")), CHOOSE(MOD(A2,10)+1,"th","st","nd","rd","th","th","th","th","th","th"))
Recipe, demo & practice file →

Add leading zeros to numbers to a fixed width with TEXT.

=TEXT(A2, "00000")
Recipe, demo & practice file →

Fix PROPER's mistakes (McDonald, IBM) with SUBSTITUTE patches.

=SUBSTITUTE(PROPER(A2), "Mcd", "McD")
Recipe, demo & practice file →

Scrub extra and hidden spaces from imported text with TRIM + CLEAN.

=TRIM(CLEAN(A2))
Recipe, demo & practice file →

Flatten in-cell line breaks to spaces with SUBSTITUTE + CHAR(10).

=SUBSTITUTE(A2, CHAR(10), " ")
Recipe, demo & practice file →

Flatten in-cell line breaks to spaces with SUBSTITUTE + CHAR(10).

=TRIM(SUBSTITUTE(A2, CHAR(10), " "))
Recipe, demo & practice file →

Strip digits from text, keeping letters, with REGEXREPLACE.

=REGEXREPLACE(A2, "[0-9]", "")
Recipe, demo & practice file →

Strip unwanted characters with nested SUBSTITUTE (or keep only digits).

=SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(A2,"-",""),"(",""),")","")," ","")
Recipe, demo & practice file →

Reverse the characters in a string with TEXTJOIN, MID and SEQUENCE.

=TEXTJOIN("", 1, MID(A2, SEQUENCE(LEN(A2), 1, LEN(A2), -1), 1))
Recipe, demo & practice file →

Capitalize only the first letter (sentence case).

=UPPER(LEFT(A2,1)) & LOWER(MID(A2,2,LEN(A2)))
Recipe, demo & practice file →

Split letters from numbers in a code like ABC123.

=REGEXEXTRACT(A2, "[A-Za-z]+") // letters =REGEXEXTRACT(A2, "[0-9]+") // numbers
Recipe, demo & practice file →

Break one cell into columns on a delimiter with TEXTSPLIT (or LEFT/MID/FIND).

=TEXTSPLIT(A2, "-")
Recipe, demo & practice file →

Split a delimited cell into rows (down a column) with TEXTSPLIT.

=TEXTSPLIT(A2, , ",")
Recipe, demo & practice file →

Convert Last, First into First Last and back.

=TRIM(MID(A2, FIND(",", A2) + 1, 100)) & " " & LEFT(A2, FIND(",", A2) - 1)
Recipe, demo & practice file →

Date & Time

Work with dates: ages, durations, month boundaries.

Add (or subtract) working days to a date with WORKDAY.

=WORKDAY(A2, 10, holidays)
Recipe, demo & practice file →

Shift a date by whole months or years with EDATE.

=EDATE(A2, 3)
Recipe, demo & practice file →

Express an age or duration in weeks or total months.

=(TODAY() - B1) / 7 // weeks =DATEDIF(B1, TODAY(), "m") // total months
Recipe, demo & practice file →

Turn a birthdate into an age in whole years with DATEDIF and TODAY — updates itself daily.

=DATEDIF(B2, TODAY(), "Y")
Recipe, demo & practice file →

Calculate hours between two times by subtracting and multiplying by 24.

=(B2 - A2) * 24
Recipe, demo & practice file →

Convert raw seconds into a readable h:mm:ss duration with TEXT.

=TEXT(A2/86400, "[h]:mm:ss")
Recipe, demo & practice file →

Turn text dates into real dates with DATEVALUE or a DATE rebuild.

=DATEVALUE(A2)
Recipe, demo & practice file →

Convert a time like 8:30 to 8.5 decimal hours.

=A2 * 24
Recipe, demo & practice file →

Show days remaining until a due date, with overdue handling.

=Deadline-TODAY()
Recipe, demo & practice file →

Count how many Saturdays and Sundays fall between a start and end date.

=SUMPRODUCT(--(WEEKDAY(ROW(INDIRECT(start&":"&end)),2)>5))
Recipe, demo & practice file →

Count working days between dates, skipping weekends and holidays, with NETWORKDAYS.

=NETWORKDAYS(B1, B2, D2:D5)
Recipe, demo & practice file →

Count how many Mondays (etc.) are in a month.

=SUMPRODUCT((WEEKDAY(ROW(INDIRECT(A1&":"&EOMONTH(A1,0)))) = 2) * 1)
Recipe, demo & practice file →

Return whole weeks (and leftover days) between a start and end date.

=INT((End-Start)/7)
Recipe, demo & practice file →

Show days, hours, and minutes remaining to a target with NOW.

=INT(B1-NOW()) & "d " & TEXT(B1-NOW(), "h\h m\m")
Recipe, demo & practice file →

Count days on the 30/360 basis used in bond and accounting math with DAYS360.

=DAYS360(B1, B2)
Recipe, demo & practice file →

Count days until or since a date with simple date subtraction and TODAY.

=A2 - TODAY()
Recipe, demo & practice file →

Compute days in a year, leap-aware (365 or 366).

=DATE(YEAR(A2)+1, 1, 1) - DATE(YEAR(A2), 1, 1)
Recipe, demo & practice file →

Break an age into exact years, months, and days with DATEDIF.

=DATEDIF(B1, TODAY(), "y") & " yrs, " & DATEDIF(B1, TODAY(), "ym") & " mo, " & DATEDIF(B1, TODAY(), "md") & " days"
Recipe, demo & practice file →

Jump to the next specific weekday from a date with WEEKDAY and MOD.

=A2 + MOD(DOW - WEEKDAY(A2) + 7, 7)
Recipe, demo & practice file →

Find the first or last day of a date's quarter.

=EOMONTH(A2, MOD(3 - MOD(MONTH(A2)-1, 3), 3))
Recipe, demo & practice file →

Get the first or last day of any month with EOMONTH — leap-year safe.

=EOMONTH(A2, 0) // last day of A2's month =EOMONTH(A2, -1) + 1 // first day of A2's month
Recipe, demo & practice file →

Map any date to its fiscal year and quarter for non-January calendars.

=YEAR(A2) + (MONTH(A2)>=7) // fiscal year =MOD(CEILING(MONTH(A2)-6, 3)/3 + 3, 4)+1 // fiscal quarter
Recipe, demo & practice file →

Spill a list of evenly spaced dates (weekly, monthly) with SEQUENCE.

=start+(SEQUENCE(n)-1)*7
Recipe, demo & practice file →

Get the calendar date that a given year and week number starts on.

=DATE(B1,1,4) - WEEKDAY(DATE(B1,1,4),2) + 1 + (B2-1)*7
Recipe, demo & practice file →

Get the day-of-week name from a date with TEXT (dddd / ddd).

=TEXT(A2, "dddd")
Recipe, demo & practice file →

Turn a date into its calendar quarter with MONTH and ROUNDUP.

=ROUNDUP(MONTH(A2)/3, 0)
Recipe, demo & practice file →

Get the ISO or US week number of a date with ISOWEEKNUM / WEEKNUM.

=ISOWEEKNUM(A2)
Recipe, demo & practice file →

Total hours for a shift that crosses midnight with MOD.

=MOD(B2 - A2, 1) * 24
Recipe, demo & practice file →

Find the last (or first) business day of any month with WORKDAY + EOMONTH.

=WORKDAY(EOMONTH(A2,0)+1, -1, holidays)
Recipe, demo & practice file →

Turn a month number into its name (June from 6).

=TEXT(DATE(2000, A2, 1), "mmmm")
Recipe, demo & practice file →

Count whole or calendar months between two dates.

=DATEDIF(B1, B2, "m")
Recipe, demo & practice file →

Find the next anniversary, birthday, or renewal date with DATE.

=DATE(YEAR(TODAY()) + (DATE(YEAR(TODAY()),MONTH(B1),DAY(B1))<TODAY()), MONTH(B1), DAY(B1))
Recipe, demo & practice file →

Find the nth weekday of a month (3rd Thursday) with DATE and WEEKDAY.

=DATE(Y,M,1) + MOD(DOW - WEEKDAY(DATE(Y,M,1)), 7) + (N-1)*7
Recipe, demo & practice file →

Find how many days are in a month with EOMONTH and DAY (leap-safe).

=DAY(EOMONTH(A2, 0))
Recipe, demo & practice file →

Count overlapping days between two date ranges with MIN/MAX.

=MAX(0, MIN(C1,C2) - MAX(B1,B2) + 1)
Recipe, demo & practice file →

Round time to the nearest 15 minutes (or any interval) with MROUND.

=MROUND(A2, "0:15")
Recipe, demo & practice file →

Shift a date back a year for YoY comparisons with EDATE.

=EDATE(A2, -12)
Recipe, demo & practice file →

Split daily hours into regular and overtime with MIN and MAX.

=MIN(A2, 8) // regular hours =MAX(A2 - 8, 0) // overtime hours
Recipe, demo & practice file →

Total hours past 24 using the [h]:mm format instead of letting them wrap.

=SUM(B2:B6) // then format the cell as [h]:mm
Recipe, demo & practice file →

Find which week of the month a date falls in.

=WEEKNUM(A2) - WEEKNUM(DATE(YEAR(A2), MONTH(A2), 1)) + 1
Recipe, demo & practice file →

Count business days between dates, skipping weekends and holidays, with NETWORKDAYS.

=NETWORKDAYS(B2, C2)
Recipe, demo & practice file →

Count working days left until a deadline with NETWORKDAYS.

=NETWORKDAYS(TODAY(), B1, holidays)
Recipe, demo & practice file →

Dynamic Arrays

Modern spilling formulas — FILTER, UNIQUE, SORT — that update themselves.

Aggregate an array to one value with REDUCE and LAMBDA.

=REDUCE(0, B2:B100, LAMBDA(acc, val, acc + (val>100)*val))
Recipe, demo & practice file →

Build a reusable custom function with LAMBDA + Name Manager.

=LAMBDA(price, price * 1.08)
Recipe, demo & practice file →

Build a calculated grid from row/column positions with MAKEARRAY.

=MAKEARRAY(3, 3, LAMBDA(r, c, r * c))
Recipe, demo & practice file →

Append ranges into one with VSTACK and HSTACK.

=VSTACK(Jan, Feb, Mar)
Recipe, demo & practice file →

Make a live cross-tab with PIVOTBY.

=PIVOTBY(Region, Quarter, Sales, SUM)
Recipe, demo & practice file →

Pull every record matching a condition into a report area with FILTER (or INDEX/SMALL).

=FILTER(A2:C9, B2:B9=F1, "None")
Recipe, demo & practice file →

Filter rows on AND / OR conditions with FILTER.

=FILTER(data, (Region="East")*(Sales>1000))
Recipe, demo & practice file →

Extract every row that meets a condition into a live, self-updating range with FILTER.

=FILTER(A2:C10, B2:B10=F1, "No matches")
Recipe, demo & practice file →

Flatten a grid into one column with TOCOL (or TOROW).

=TOCOL(B2:D10, 1)
Recipe, demo & practice file →

Spill a list of numbers, dates, or a grid with SEQUENCE.

=SEQUENCE(10)
Recipe, demo & practice file →

Pad an array to a fixed size with EXPAND.

=EXPAND(A2:A4, 5, 1, 0)
Recipe, demo & practice file →

Pick and reorder rows or columns with CHOOSEROWS/CHOOSECOLS.

=CHOOSECOLS(A2:E100, 3, 1, 2)
Recipe, demo & practice file →

Reference a whole spill range with the # operator.

=SUM(A2#)
Recipe, demo & practice file →

Fold a list into a grid of any width with WRAPROWS / WRAPCOLS.

=WRAPROWS(A2:A13, 3)
Recipe, demo & practice file →

Return a whole row of fields with one XLOOKUP.

=XLOOKUP(A2, IDs, data[Name]:data[Sales])
Recipe, demo & practice file →

Make running totals, max, or product with SCAN and LAMBDA.

=SCAN(0, B2:B6, LAMBDA(acc, val, acc + val))
Recipe, demo & practice file →

Show each value as a share of total with PERCENTOF.

=PERCENTOF(B2, B2:B10)
Recipe, demo & practice file →

Sort a table by several keys with SORTBY (live formula).

=SORTBY(A2:C100, A2:A100, 1, C2:C100, -1)
Recipe, demo & practice file →

Sort by a helper column or custom order with SORTBY.

=SORTBY(Names, Scores, -1)
Recipe, demo & practice file →

Split a cell into columns (or a grid) with TEXTSPLIT.

=TEXTSPLIT(A2, ",")
Recipe, demo & practice file →

Grab text before or after a delimiter with TEXTBEFORE/TEXTAFTER.

=TEXTBEFORE(A2, "@") // user =TEXTAFTER(A2, "@") // domain
Recipe, demo & practice file →

Summarize each row or column with BYROW / BYCOL.

=BYROW(B2:D10, LAMBDA(row, SUM(row)))
Recipe, demo & practice file →

Build a grouped summary in one formula with GROUPBY.

=GROUPBY(Region, Sales, SUM)
Recipe, demo & practice file →

Transform every value of an array with MAP and LAMBDA.

=MAP(B2:B100, LAMBDA(p, p * 1.08))
Recipe, demo & practice file →

Keep or remove the first/last rows with TAKE and DROP.

=TAKE(A2:C100, 5) // first 5 rows =DROP(A1:C100, 1) // drop the header row
Recipe, demo & practice file →

Build a distinct list with counts (UNIQUE + COUNTIF).

=HSTACK(UNIQUE(A2:A100), COUNTIF(A2:A100, UNIQUE(A2:A100)))
Recipe, demo & practice file →

Turn a column with repeats into a clean, alphabetized list with SORT(UNIQUE()).

=SORT(UNIQUE(A2:A10))
Recipe, demo & practice file →

Math

Number crunching — SUMPRODUCT, MOD, roots, bases, units, combinatorics, and random.

Count selections and arrangements with COMBIN, PERMUT and FACT.

=COMBIN(10, 3)
Recipe, demo & practice file →

Convert between decimal, binary, hex and octal with DEC2BIN/HEX2DEC.

=DEC2HEX(A2) // decimal → hex =DEC2BIN(A2) // decimal → binary
Recipe, demo & practice file →

Convert miles, kg, Celsius, hours and more with the CONVERT function.

=CONVERT(5, "mi", "km")
Recipe, demo & practice file →

Cycle through a list repeatedly with MOD — round-robin assignment, alternating bands, repeating schedules.

=MOD(ROW()-2, N) + 1
Recipe, demo & practice file →

Straight-line distance between two points with SQRT and SUMSQ — the Pythagorean theorem in 2D or 3D.

=SQRT(SUMSQ(x2-x1, y2-y1))
Recipe, demo & practice file →

Compute n! and build permutations and combinations with FACT, COMBIN and PERMUT.

=FACT(A2)
Recipe, demo & practice file →

Generate random numbers and random picks with RANDBETWEEN and RAND.

=RANDBETWEEN(1, 100)
Recipe, demo & practice file →

Find the greatest common divisor and least common multiple, and simplify ratios.

=GCD(A2, B2) // largest shared divisor =LCM(A2, B2) // smallest shared multiple
Recipe, demo & practice file →

INT vs TRUNC: both drop decimals, but they differ on negatives — chop toward zero vs round down.

=TRUNC(A2) // chops decimals =INT(A2) // rounds down
Recipe, demo & practice file →

Take logs in any base with LOG, LN and LOG10 — for growth rates, decibels, pH and doubling time.

=LOG(A2, B2)
Recipe, demo & practice file →

Multiply every value in a range with PRODUCT (compound factors).

=PRODUCT(B2:B6)
Recipe, demo & practice file →

Multiply arrays and add, or count/sum on multiple conditions, with SUMPRODUCT.

=SUMPRODUCT(B2:B10, C2:C10)
Recipe, demo & practice file →

Raise to a power, take any root, or compute e^x with POWER, SQRT and EXP.

=POWER(A2, B2) // or =A2^B2
Recipe, demo & practice file →

Raise to powers and take square or nth roots with POWER, ^ and SQRT.

=A2 ^ 3 // A2 cubed =A2 ^ (1/3) // cube root of A2
Recipe, demo & practice file →

Generate a random decimal in any range with RAND — scaled and shifted for simulations and test data.

=A2 + RAND() * (B2 - A2)
Recipe, demo & practice file →

Shuffle a list or sample without duplicates using SORTBY + RANDARRAY.

=SORTBY(A2:A20, RANDARRAY(ROWS(A2:A20)))
Recipe, demo & practice file →

Get remainders and build cycles, odd/even tests and wraps with MOD.

=MOD(A2, 3)
Recipe, demo & practice file →

Convert numbers to Roman numerals and back with ROMAN and ARABIC.

=ROMAN(A2)
Recipe, demo & practice file →

Build a cumulative product with PRODUCT and an expanding range — compound growth factors and indices.

=PRODUCT($B$2:B2)
Recipe, demo & practice file →

Split a total into whole groups and a remainder with QUOTIENT and MOD.

=QUOTIENT(A2, 12) // whole dozens =MOD(A2, 12) // leftover units
Recipe, demo & practice file →

Square every value and total them in one function with SUMSQ — the basis of variance, distance and least-squares.

=SUMSQ(B2:B100)
Recipe, demo & practice file →

Use SIN, COS and TAN with degrees by wrapping angles in RADIANS — heights, distances and angles.

=SIN(RADIANS(A2))
Recipe, demo & practice file →

Rank

Order and position values — leaderboards, rankings, top performers.

Rank a list highest-to-lowest with RANK.EQ, including a no-gaps tiebreaker.

=RANK.EQ(B2, $B$2:$B$8)
Recipe, demo & practice file →

Percentage

Percent change, percent of total, and percentage math.

Build a running cumulative percent (Pareto).

=SUM($B$2:B2) / SUM($B$2:$B$100)
Recipe, demo & practice file →

Calculate percent change and percent of total — the right base and formatting.

=(B2 - A2) / A2
Recipe, demo & practice file →

Round

Round to decimals, multiples, or always up/down.

Always round up or down with ROUNDUP, ROUNDDOWN, CEILING and FLOOR.

=ROUNDUP(A2, 0) // up to whole number =CEILING(A2, 10) // up to next multiple of 10
Recipe, demo & practice file →

Round halves down (2.5 to 2) instead of away from zero with a ROUNDUP minus-0.5 trick.

=ROUNDUP(A2 - 0.5, 0)
Recipe, demo & practice file →

Round up or down to the nearest multiple — to the next $5 or down to 100 — with CEILING, FLOOR and MROUND.

=CEILING(A2, 5)
Recipe, demo & practice file →

Round a percentage cleanly by rounding the underlying decimal — 2 places for whole percent, 3 for one decimal.

=ROUND(A2, 2)
Recipe, demo & practice file →

Round money cleanly to cents, nickels or whole dollars with ROUND and MROUND — fix floating-point pennies.

=ROUND(A2, 2)
Recipe, demo & practice file →

Round up to the next even or odd integer with EVEN and ODD — for pairs, panels and centered counts.

=EVEN(A2)
Recipe, demo & practice file →

Round to N significant figures with ROUND and LOG10.

=ROUND(A2, 3 - 1 - INT(LOG10(ABS(A2))))
Recipe, demo & practice file →

Round to the nearest thousand or million with ROUND and negative digits — cleaner dashboard figures.

=ROUND(A2, -3)
Recipe, demo & practice file →

Round to the nearest 0.5 (or quarter, dime) with MROUND, CEILING and FLOOR — for half-step pricing.

=MROUND(A2, 0.5)
Recipe, demo & practice file →

Round to decimal places with ROUND or to any multiple with MROUND.

=ROUND(A2, 2) // 2 decimal places =MROUND(A2, 25) // nearest multiple of 25
Recipe, demo & practice file →

Financial

Loans, savings, interest, and investment math.

Turn a lump sum into a level monthly payout.

=PMT(B3/12, B2*12, -B1)
Recipe, demo & practice file →

Find the lump-sum balloon owed at loan maturity.

=-FV(B2/12, N, B3, B1)
Recipe, demo & practice file →

Break-Even Point

All versions

Find the units needed to cover costs (fixed / contribution margin).

=B1 / (B2 - B3)
Recipe, demo & practice file →

Compute the compound annual growth rate from a start and end value.

=(B2 / B1)^(1 / B3) - 1
Recipe, demo & practice file →

Find how many units you must sell to cover fixed costs.

=FixedCosts/(Price-VariableCost)
Recipe, demo & practice file →

Calculate a fixed loan payment from rate, term and amount with PMT.

=PMT(B1/12, B2*12, B3)
Recipe, demo & practice file →

Compound Interest

All versions

Grow a lump sum with the compound interest formula (1+rate)^periods.

=B1 * (1 + B2)^B3
Recipe, demo & practice file →

Find how long a card balance takes to clear with NPER.

=NPER(B2/12, -B3, B1)
Recipe, demo & practice file →

Depreciate an asset with SLN, DDB, or SYD (straight-line vs accelerated).

=SLN(cost, salvage, life)
Recipe, demo & practice file →

Value future cash flows today with a DCF (NPV).

=NPV(B1, B2:B6)
Recipe, demo & practice file →

Compute dividend yield and annual income.

=B1 / B2
Recipe, demo & practice file →

Estimate doubling time with the Rule of 72 and compute it exactly with NPER.

=72 / (B1*100) // Rule of 72 estimate =NPER(B1, 0, -1, 2) // exact years to double
Recipe, demo & practice file →

Convert nominal to effective annual rate (APR to APY) with EFFECT/NOMINAL.

=EFFECT(0.06, 12)
Recipe, demo & practice file →

SUM totals monthly debt payments and divides by gross monthly income to produce the debt-to-income ratio lenders use to gauge how much of your income is already committed before a new loan payment is added.

=SUM(MonthlyDebts)/GrossMonthlyIncome
Recipe, demo & practice file →

Compute the full PITI mortgage payment with taxes & insurance.

=PMT(B2/12, B3*12, -B1) + (B4 + B5)/12
Recipe, demo & practice file →

Project what regular savings grow to with FV and compound interest.

=FV(B1/12, B2*12, -B3)
Recipe, demo & practice file →

See how extra payments shorten a loan with NPER.

=NPER(B1/12, -B2, B3)
Recipe, demo & practice file →

Find an interest-only loan payment.

=B1 * B2/12
Recipe, demo & practice file →

Find an investment's annual return where NPV is zero with IRR.

=IRR(B2:B7)
Recipe, demo & practice file →

Split each loan payment into interest and principal with IPMT and PPMT.

=PPMT(B1/12, A2, B2*12, B3) // principal in payment A2 =IPMT(B1/12, A2, B2*12, B3) // interest in payment A2
Recipe, demo & practice file →

Find the monthly deposit to reach a savings goal with PMT.

=PMT(B1/12, B2*12, 0, -B3)
Recipe, demo & practice file →

Value future cash flows in today's money with NPV (initial added outside).

=NPV(B1, B3:B7) + B2
Recipe, demo & practice file →

Find what future money or payments are worth today with PV.

=PV(B1, B2, -B3)
Recipe, demo & practice file →

Price a bond as the present value of its cash flows.

=-PV(B4, B3, B1*B2, B1)
Recipe, demo & practice file →

Tell profit margin from markup, and price for a target margin.

=(B2 - B1) / B2 // profit margin =(B2 - B1) / B1 // markup
Recipe, demo & practice file →

Compute return on investment and payback period.

=(B1 - B2) / B2
Recipe, demo & practice file →

Adjust a return for inflation (Fisher equation).

=(1 + B1) / (1 + B2) - 1
Recipe, demo & practice file →

Find the deposit to reach a target by a future date.

=PMT(B3/12, B2*12, 0, -B1)
Recipe, demo & practice file →

Value a payment that lasts forever (C/r).

=C / r
Recipe, demo & practice file →

Calculate annualized return on irregular cash-flow dates with XIRR.

=XIRR(B2:B6, A2:A6)
Recipe, demo & practice file →

Find a bond's yield to maturity with RATE.

=RATE(B4, B3, -B1, B2)
Recipe, demo & practice file →

Business

Everyday business math — invoices, commissions, budgets, pricing, payroll, inventory, and cash flow.

Age unpaid invoices into 30/60/90-day buckets.

=IFS(TODAY()-B2<=30,"0-30", TODAY()-B2<=60,"31-60", TODAY()-B2<=90,"61-90", TRUE,"90+")
Recipe, demo & practice file →

Allocate a shared cost across departments by weight.

=$E$1 * B2 / SUM($B$2:$B$10)
Recipe, demo & practice file →

Annualize a year-to-date figure into a full-year run-rate.

=B1 / B2 * 12
Recipe, demo & practice file →

Apply a discount then tax in the right order.

=B1 * (1 - B2) * (1 + B3)
Recipe, demo & practice file →

Back out the tax from a tax-inclusive price.

=B1 / (1 + B2) // net price =B1 - B1/(1 + B2) // tax portion
Recipe, demo & practice file →

Bill hours at different rates with SUMPRODUCT.

=SUMPRODUCT(B2:B10, C2:C10)
Recipe, demo & practice file →

Compute budget vs actual variance in dollars and percent.

=C2 - B2 // variance ($) =IFERROR((C2-B2)/B2, "") // variance (%)
Recipe, demo & practice file →

Compare two loans by payment and total interest with PMT.

=PMT(B2/12, B3*12, -B1)
Recipe, demo & practice file →

Find contribution margin per unit and as a ratio.

=B1 - B2 // contribution margin =(B1 - B2) / B1 // CM ratio
Recipe, demo & practice file →

Convert currency with a maintained exchange-rate table.

=B2 * VLOOKUP("EUR", $E$2:$F$6, 2, FALSE)
Recipe, demo & practice file →

Spread fixed plus variable costs into a per-unit cost.

=B1/B3 + B2
Recipe, demo & practice file →

Take gross pay down to net with stacked deductions.

=B1 - ROUND(B1*taxRate, 2) - ROUND(B1*retireRate, 2) - fixedDeductions
Recipe, demo & practice file →

Flag low stock and compute how much to reorder.

=IF(B2 <= C2, "REORDER", "OK")
Recipe, demo & practice file →

Total an invoice's line items and tax with SUMPRODUCT.

=SUMPRODUCT(B2:B10, C2:C10)
Recipe, demo & practice file →

Compare the net cost of leasing versus buying.

=leasePayment*months // lease total =price - resaleValue // buy net cost
Recipe, demo & practice file →

Look up the right sales-tax rate by region with VLOOKUP.

=amount * VLOOKUP(B2, $E$2:$F$6, 2, FALSE)
Recipe, demo & practice file →

Chain cost-to-wholesale-to-retail markups correctly.

=B1 * (1 + B2) * (1 + B3)
Recipe, demo & practice file →

Calculate markup and margin from cost and price, and convert between them.

=(Price-Cost)/Cost vs =(Price-Cost)/Price
Recipe, demo & practice file →

Find the payback period from a cash-flow stream.

=C1 + B2
Recipe, demo & practice file →

Roll a sales log into profit by product with SUMIFS.

=SUMIFS(revenue, product, "Widget") - SUMIFS(cost, product, "Widget")
Recipe, demo & practice file →

Sum a trailing 12-month (TTM) window that slides forward.

=SUM(OFFSET(B2, 0, 0, -12, 1))
Recipe, demo & practice file →

Keep a running cash balance as money comes in and out.

=D1 + B2 - C2
Recipe, demo & practice file →

Pay a sales commission that steps up by tier with VLOOKUP.

=B2 * VLOOKUP(B2, $E$2:$F$5, 2, TRUE)
Recipe, demo & practice file →

Add a tip and split a bill among people.

=B1 * (1 + B2) / B3
Recipe, demo & practice file →

Apply volume/quantity discount pricing with a break table.

=B2 * VLOOKUP(B2, $E$2:$F$5, 2, TRUE)
Recipe, demo & practice file →

Charts

Visualize data — sparklines, dynamic charts, KPI cards, gauges, and dashboard techniques.

Add tiny in-cell line, column, or win/loss sparkline charts.

Insert → Sparklines → Line → Data range: B2:M2
Recipe, demo & practice file →

Make a chart auto-expand with new data (Table or OFFSET).

=OFFSET($B$2, 0, 0, COUNTA($B$2:$B$1000), 1)
Recipe, demo & practice file →

Build a KPI card with a value and up/down delta.

=TEXT(B1,"$#,##0")&" "&IF(B1>=B2,"▲","▼")&TEXT((B1-B2)/B2,"0%")
Recipe, demo & practice file →

Build a bullet chart (actual vs target vs bands).

Poor | Fair | Good (bands) + Actual (overlaid bar) + Target (marker)
Recipe, demo & practice file →

Combine columns and a line on two axes.

Insert → Combo Chart → set one series to Line, check Secondary Axis
Recipe, demo & practice file →

Put custom text labels on chart points from cells.

Label cell: =A2 & ": " & TEXT(B2, "$#,##0")
Recipe, demo & practice file →

Make a goal thermometer that fills toward a target.

=MIN(raised/goal, 1)
Recipe, demo & practice file →

Build a histogram by binning with FREQUENCY.

=FREQUENCY(A2:A100, C2:C6)
Recipe, demo & practice file →

Link a chart title to a cell so it updates itself.

A1: ="Sales — "&TEXT(SUM(data),"$#,##0")&" ("&period&")"
Recipe, demo & practice file →

Draw a percent-of-goal progress bar with REPT.

=REPT("█", MIN(B1/B2,1)*20) & " " & TEXT(B1/B2,"0%")
Recipe, demo & practice file →

Build a waterfall (bridge) chart with helper columns.

Base = running total before this step; Bar = the step amount
Recipe, demo & practice file →

Show streaks with a direction-only win/loss sparkline.

Insert → Sparklines → Win/Loss → Data: B2:M2
Recipe, demo & practice file →

Analysis

What-if tools — PivotTables, Goal Seek, data tables, scenarios, and sensitivity analysis.

Add a calculated field (like margin %) inside a PivotTable.

Name: Margin % Formula: = Profit / Revenue
Recipe, demo & practice file →

Compare best/base/worst scenarios with a selector and CHOOSE.

=CHOOSE($B$1, worstValue, baseValue, bestValue)
Recipe, demo & practice file →

Find break-even by driving profit to zero with Goal Seek.

Goal Seek → Set: profit cell To: 0 By changing: units cell
Recipe, demo & practice file →

Solve backward for the input that hits a target with Goal Seek.

Set cell: [result] To value: [target] By changing: [input]
Recipe, demo & practice file →

Group PivotTable dates into months, quarters, or years.

Group → select Months (and/or Quarters, Years)
Recipe, demo & practice file →

See how a loan payment moves as the rate changes.

=PMT(rate/12, N, -P)
Recipe, demo & practice file →

Sweep one input across a range with a data table.

Data → What-If Analysis → Data Table → Column input cell: [the input]
Recipe, demo & practice file →

Model total profit from a product mix with SUMPRODUCT.

=SUMPRODUCT(B2:B10, C2:C10)
Recipe, demo & practice file →

Pull a PivotTable value by field name with GETPIVOTDATA.

=GETPIVOTDATA("Sales", $A$3, "Region", "East")
Recipe, demo & practice file →

Show PivotTable values as a percent of the total.

Show Values As → % of Grand Total
Recipe, demo & practice file →

Solve the price needed to hit a profit target.

=(fixed + target) / units + variable
Recipe, demo & practice file →

Build a result grid varying two inputs at once.

Data → What-If Analysis → Data Table → Row input cell + Column input cell
Recipe, demo & practice file →

Statistics

Median, percentiles, spread, correlation, forecasting, and outliers.

Track the highest value seen so far down a column with an expanding MAX.

=MAX($B$2:B2)
Recipe, demo & practice file →

Compare relative spread across datasets with STDEV / AVERAGE.

=STDEV(B2:B20) / AVERAGE(B2:B20)
Recipe, demo & practice file →

Put a margin of error around a sample mean with CONFIDENCE.

=CONFIDENCE(0.05, B1, B2)
Recipe, demo & practice file →

Measure how two columns move together with CORREL (-1 to +1).

=CORREL(B2:B100, C2:C100)
Recipe, demo & practice file →

Measure whether two variables move together with COVAR.

=COVAR(B2:B20, C2:C20)
Recipe, demo & practice file →

Flag outliers with the IQR rule (QUARTILE) or a z-score test.

=OR(B2 < Q1 - 1.5*IQR, B2 > Q3 + 1.5*IQR)
Recipe, demo & practice file →

Project future values along a trend with TREND.

=TREND(known_ys, known_xs, new_xs)
Recipe, demo & practice file →

Project a future value along a trend line with FORECAST or TREND.

=FORECAST(newX, known_Ys, known_Xs)
Recipe, demo & practice file →

Average compounding growth rates correctly with GEOMEAN.

=GEOMEAN(B2:B6)
Recipe, demo & practice file →

Average rates and ratios correctly with HARMEAN.

=HARMEAN(B2:B100)
Recipe, demo & practice file →

Measure average spread with AVEDEV — the mean absolute distance from the average, robust to outliers.

=AVEDEV(B2:B100)
Recipe, demo & practice file →

Compare mean, median, and mode for the center.

=AVERAGE(B2:B100) =MEDIAN(B2:B100) =MODE(B2:B100)
Recipe, demo & practice file →

Find the median within a group with MEDIAN+FILTER or MEDIAN(IF()).

=MEDIAN(FILTER(B2:B100, A2:A100=E2))
Recipe, demo & practice file →

Find the most frequent value (number or text) with MODE.

=MODE(B2:B20)
Recipe, demo & practice file →

Rescale values to a 0-1 scale (min-max).

=(A2 - MIN($A$2:$A$100)) / (MAX($A$2:$A$100) - MIN($A$2:$A$100))
Recipe, demo & practice file →

Compute percentiles and quartiles with PERCENTILE and QUARTILE.

=PERCENTILE(B2:B100, 0.9)
Recipe, demo & practice file →

Find a value's percentile standing within a dataset with PERCENTRANK.

=PERCENTRANK($B$2:$B$20, A2)
Recipe, demo & practice file →

Measure how well a line fits with R-squared (RSQ).

=RSQ(B2:B100, A2:A100)
Recipe, demo & practice file →

Measure spread with the range and interquartile range.

=MAX(B2:B100)-MIN(B2:B100) // range =QUARTILE(B2:B100,3)-QUARTILE(B2:B100,1) // IQR
Recipe, demo & practice file →

Rank values within each group with COUNTIFS.

=COUNTIFS(group, A2, value, ">"&B2) + 1
Recipe, demo & practice file →

Get a regression line's slope and intercept.

=SLOPE(B2:B100, A2:A100) =INTERCEPT(B2:B100, A2:A100)
Recipe, demo & practice file →

Track changing volatility with a rolling standard deviation.

=STDEV(OFFSET(B6, 0, 0, -5, 1))
Recipe, demo & practice file →

Describe distribution shape with SKEW and KURT.

=SKEW(B2:B100) =KURT(B2:B100)
Recipe, demo & practice file →

Measure spread with STDEV.S (sample) or STDEV.P (population).

=STDEV.S(B2:B100)
Recipe, demo & practice file →

Find how precise a sample mean is (standard error).

=STDEV(B2:B100) / SQRT(COUNT(B2:B100))
Recipe, demo & practice file →

Finds the gap between a class's actual average score and a target average, then adds that same gap to every score, so the whole distribution shifts up (or down) while each student keeps their relative rank.

=Score+(TargetAvg-AVERAGE(AllScores))
Recipe, demo & practice file →

Average after dropping the extreme high and low values with TRIMMEAN.

=TRIMMEAN(B2:B20, 0.2)
Recipe, demo & practice file →

Compute sample or population variance (VAR.S/.P).

=VAR.S(B2:B100)
Recipe, demo & practice file →

Average prices by quantity so big lots count more than small ones.

=SUMPRODUCT(Price,Qty)/SUM(Qty)
Recipe, demo & practice file →

Measure how many standard deviations a value is from the mean.

=STANDARDIZE(A2, AVERAGE($A$2:$A$20), STDEV($A$2:$A$20))
Recipe, demo & practice file →

Advanced

Power-user formula craft — LET, LAMBDA, REGEX, and custom number formats.

Clean and reformat text by pattern with REGEXREPLACE.

=REGEXREPLACE(A2, "[^0-9]", "")
Recipe, demo & practice file →

Color or change format by value with bracketed conditions.

[Green][>=100]#,##0;[Red][<100]#,##0
Recipe, demo & practice file →

Control how numbers display with custom format codes.

#,##0;[Red](#,##0);"–";@
Recipe, demo & practice file →

Display big numbers as K or millions with a format code.

#,##0.0,, "M"
Recipe, demo & practice file →

Extract text by pattern with REGEXEXTRACT.

=REGEXEXTRACT(A2, "[0-9]+")
Recipe, demo & practice file →

Format phone or ID numbers without changing the value.

(000) 000-0000
Recipe, demo & practice file →

Hide zeros or show a dash with a number format.

#,##0;-#,##0;
Recipe, demo & practice file →

Build a clean custom function with LAMBDA + LET.

=LAMBDA(gross, disc, rate, LET(net, gross*(1-disc), net*(1+rate)))
Recipe, demo & practice file →

Name values inside a formula for clarity and speed with LET.

=LET(net, A1-A2, tax, net*0.08, net + tax)
Recipe, demo & practice file →

Write a LAMBDA that calls itself to loop without VBA.

RemoveChars = LAMBDA(txt, chars, IF(chars="", txt, RemoveChars(SUBSTITUTE(txt, LEFT(chars,1), ""), MID(chars,2,99))))
Recipe, demo & practice file →

Save a LAMBDA as a reusable custom function in Name Manager.

Name: GrossUp Refers to: =LAMBDA(net, rate, net*(1+rate))
Recipe, demo & practice file →

Validate text format with REGEXTEST (TRUE/FALSE).

=REGEXTEST(A2, "^[\w.]+@[\w.]+\.\w+$")
Recipe, demo & practice file →

Conditional Formatting

Formula-driven rules that highlight rows and cells automatically.

Add alternating row shading with ISEVEN(ROW()) — zebra stripes.

=ISEVEN(ROW())
Recipe, demo & practice file →

Build a live Gantt chart from start/end dates with a CF formula.

=AND(D$1 >= $B2, D$1 <= $C2)
Recipe, demo & practice file →

Turn numbers into a color-gradient heat map with Color Scales.

Home → Conditional Formatting → Color Scales
Recipe, demo & practice file →

Shade every cell that contains a formula (ISFORMULA).

=ISFORMULA(A1)
Recipe, demo & practice file →

Highlight cells above or below the group average automatically.

=B2 > AVERAGE($B$2:$B$20)
Recipe, demo & practice file →

Highlight values above a threshold from a cell.

=A1 > $E$1
Recipe, demo & practice file →

Highlight cells that mention a keyword with ISNUMBER + SEARCH.

=ISNUMBER(SEARCH("urgent", A1))
Recipe, demo & practice file →

Light up every cell that evaluates to an error with ISERROR.

=ISERROR(A1)
Recipe, demo & practice file →

Flag cells that are the wrong length with LEN.

=LEN(A1) <> 5
Recipe, demo & practice file →

Auto-colour rows whose expiry date is within the next 30 days.

=AND(A2>=TODAY(),A2<=TODAY()+30)
Recipe, demo & practice file →

Highlight where two columns differ.

=$A1 <> $B1
Recipe, demo & practice file →

Turn overdue dates red and upcoming ones amber with TODAY.

=B2 < TODAY()
Recipe, demo & practice file →

Shade every value that appears more than once with a COUNTIF rule.

=COUNTIF($A$2:$A$20, A2) > 1
Recipe, demo & practice file →

Shade every Nth row with a MOD rule.

=MOD(ROW(), 3) = 0
Recipe, demo & practice file →

Highlight future (or past) dates vs TODAY.

=A1 > TODAY()
Recipe, demo & practice file →

Flag missing required entries with a blank rule.

=A2 = ""
Recipe, demo & practice file →

Highlight values that appear exactly once.

=COUNTIF($A$2:$A$20, A2) = 1
Recipe, demo & practice file →

Highlight rows missing any data with COUNTBLANK in a CF rule.

=COUNTBLANK($A2:$D2) > 0
Recipe, demo & practice file →

Highlight whole rows with a formula rule — the $C2 mixed-reference trick.

=$C2="Overdue"
Recipe, demo & practice file →

Flag entries not on an allowed list with COUNTIF.

=COUNTIF($E$2:$E$10, A1) = 0
Recipe, demo & practice file →

Shade Saturdays and Sundays in a date list with WEEKDAY.

=WEEKDAY(A2, 2) > 5
Recipe, demo & practice file →

Draw a line where a sorted group changes.

=$A2 <> $A1
Recipe, demo & practice file →

Light up a whole row based on one cell using a mixed reference.

=$D2 = "Overdue"
Recipe, demo & practice file →

Flag the highest and lowest values with MAX/MIN rules.

=B2 = MAX($B$2:$B$20) // highest (green) =B2 = MIN($B$2:$B$20) // lowest (red)
Recipe, demo & practice file →

Highlight the top 10% by value with PERCENTILE.

=A1 >= PERCENTILE($A$1:$A$100, 0.9)
Recipe, demo & practice file →

Shade the top N values with a LARGE-based conditional-formatting rule.

=B2>=LARGE($B$2:$B$10, 3)
Recipe, demo & practice file →

In-Cell Data Bars

All versions

Turn a column of numbers into in-cell data bars.

Home → Conditional Formatting → Data Bars → pick a style
Recipe, demo & practice file →

Band by group, not just every other row, with a group counter.

Helper C2: =IF(A2=A1, C1, C1+1) CF rule: =ISODD($C2)
Recipe, demo & practice file →

Strike through tasks marked done with a CF rule.

=$C1 = "Done"
Recipe, demo & practice file →

Add traffic-light icons with your own number thresholds.

Home → Conditional Formatting → Icon Sets → 3 Traffic Lights
Recipe, demo & practice file →

Data Validation

Drop-down lists and controlled data entry.

Build a drop-down list with Data Validation so entry is pick-from-a-menu.

=$F$2:$F$6
Recipe, demo & practice file →

Make a cascading drop-down where the second list depends on the first (INDIRECT).

=INDIRECT(A2)
Recipe, demo & practice file →

Block duplicate entries with a COUNTIF data-validation rule.

=COUNTIF($A$2:$A$1000, A2) <= 1
Recipe, demo & practice file →

Limit a cell to whole numbers or a value range with Data Validation.

Whole number → between → 1 and 100
Recipe, demo & practice file →

Block entries that are too long or short with text-length validation.

Allow: Text length Data: equal to Length: 5
Recipe, demo & practice file →

HR & Payroll

Real-world HR and payroll math — prorating pay, overtime tiers, accruals, headcount, tenure and withholding.

Earn PTO as a rate per hour worked, rounded and capped to your plan.

=ROUND(hours_worked * accrual_rate, 2)
Recipe, demo & practice file →

Count staff active in any month from hire and termination dates with SUMPRODUCT.

=SUMPRODUCT((hire<=month_end)*((term="")+(term>month_end)))
Recipe, demo & practice file →

Total benefit costs divided by covered headcount for budgeting and benchmarking.

=SUM(benefit_costs) / employee_count
Recipe, demo & practice file →

Split hours into regular and overtime and total the pay.

=Reg*Rate + OT*Rate*1.5
Recipe, demo & practice file →

Compare pay to range midpoint (1.00 = at midpoint) for equity and positioning.

=salary / midpoint
Recipe, demo & practice file →

Divide salary by 2,080 hours for an hourly rate; multiply to reverse it.

=ROUND(annual / 2080, 2)
Recipe, demo & practice file →

Show exact length of service in years, months and days with DATEDIF.

=DATEDIF(hire,TODAY(),"y")&" yr "&DATEDIF(hire,TODAY(),"ym")&" mo "&DATEDIF(hire,TODAY(),"md")&" d"
Recipe, demo & practice file →

Separations divided by average headcount, as a percentage, with AVERAGE.

=separations / AVERAGE(beginning_headcount, ending_headcount)
Recipe, demo & practice file →

Capped Social Security (6.2%) plus uncapped Medicare (1.45%) with MIN for the wage cap.

=MIN(wages, ss_cap)*6.2% + wages*1.45%
Recipe, demo & practice file →

Spill a year of every-14-day paydays from a start date with SEQUENCE.

=start + (SEQUENCE(26,1,0) * 14)
Recipe, demo & practice file →

Scale a full-period salary by the fraction of days actually worked, rounded to the cent.

=ROUND(salary * days_worked / days_in_period, 2)
Recipe, demo & practice file →

Round punch times to the nearest 15 minutes for clean payroll totals.

=MROUND(time, "0:15")
Recipe, demo & practice file →

Apply night/weekend premiums as a rate multiplier or flat add with IF or a lookup.

=hours * rate * IF(shift="Night", 1.1, 1)
Recipe, demo & practice file →

Pay regular, 1.5x and 2x bands correctly with MIN, MAX and MEDIAN as a clamp.

=rate*MIN(h,40) + rate*1.5*MEDIAN(h-40,0,20) + rate*2*MAX(h-60,0)
Recipe, demo & practice file →

Real Estate

Investment-property and brokerage math — cap rate, cash-on-cash, NOI, DSCR, yields, commissions and screening rules.

NOI divided by property value — the income yield used to compare and value properties.

=NOI / property_value
Recipe, demo & practice file →

Annual cash flow divided by the actual cash you invested — the leveraged return on your money.

=annual_cash_flow / cash_invested
Recipe, demo & practice file →

NOI divided by annual debt payments — the coverage ratio lenders use to size loans.

=NOI / annual_debt_service
Recipe, demo & practice file →

Price divided by annual gross rent — a fast screening ratio for income properties.

=property_price / annual_gross_rent
Recipe, demo & practice file →

Loan amount divided by property value — the lender's core risk and equity gauge.

=loan_amount / property_value
Recipe, demo & practice file →

70% of after-repair value minus repairs — the flipper's maximum allowable offer.

=ARV * 0.70 - repair_costs
Recipe, demo & practice file →

Effective income minus operating expenses (before the mortgage) — the base metric for property analysis.

=effective_gross_income - operating_expenses
Recipe, demo & practice file →

Price divided by living area — the size-normalized metric for comps and valuation.

=price / square_feet
Recipe, demo & practice file →

Layer commission, side share and agent split to find the agent's take from a sale.

=price * commission_rate * side_share * agent_split
Recipe, demo & practice file →

Annual rent as a percentage of value — gross uses rent alone, net subtracts expenses.

=annual_rent / property_value
Recipe, demo & practice file →

Flag whether monthly rent clears 1% of price — a fast rental screening check with IF.

=IF(monthly_rent >= price*1%, "Pass", "Below")
Recipe, demo & practice file →

Discount potential rent by an expected vacancy rate for realistic effective income.

=potential_rent * (1 - vacancy_rate)
Recipe, demo & practice file →

Retail & Inventory

Merchandising and stock math — margin vs markup, turnover, sell-through, reorder points, EOQ, ABC, GMROI and markdowns.

Band inventory items A/B/C by their cumulative share of value with nested IFs.

=IF(cum% <= 80%, "A", IF(cum% <= 95%, "B", "C"))
Recipe, demo & practice file →

Average beginning and ending (or monthly) stock — the base for turnover and DIO.

=(beginning_inventory + ending_inventory) / 2
Recipe, demo & practice file →

Average inventory over COGS times 365 — how many days stock sits before selling.

=average_inventory / COGS * 365
Recipe, demo & practice file →

The square-root formula for the order size that minimizes ordering plus holding cost.

=SQRT(2 * annual_demand * order_cost / holding_cost)
Recipe, demo & practice file →

Gross-margin dollars per dollar of inventory — margin and turnover combined.

=gross_margin_dollars / average_inventory_cost
Recipe, demo & practice file →

Book stock minus physical count, over sales — inventory lost to theft, damage and error.

=(book_inventory - counted_inventory) / sales
Recipe, demo & practice file →

COGS divided by average inventory — how many times stock cycles in a period.

=COGS / average_inventory
Recipe, demo & practice file →

Margin is profit over price, markup is profit over cost — plus how to convert and price.

=(price - cost) / price
Recipe, demo & practice file →

Sale price, saving, and correctly stacked markdowns for clearance and promotions.

=original_price * (1 - markdown_rate)
Recipe, demo & practice file →

Lead-time demand plus a safety buffer — the stock level that triggers a reorder.

=daily_demand * lead_time_days + safety_stock
Recipe, demo & practice file →

Sell-Through Rate

All versions

Units sold divided by units received — how fast a product moves through stock.

=units_sold / units_received
Recipe, demo & practice file →

Units on hand divided by the sales rate — how many weeks of supply you hold.

=units_on_hand / average_weekly_sales
Recipe, demo & practice file →

Restaurant & Hospitality

Food, beverage, and lodging math — food and labor cost percentages, recipe costing, pour cost, RevPAR, ADR and break-even.

Room revenue divided by rooms sold — the average rate achieved per occupied room.

=room_revenue / rooms_sold
Recipe, demo & practice file →

Beverage Pour Cost

All versions

Cost per pour divided by drink price — the bar's pour cost (target 18–24%).

=cost_per_pour / drink_price
Recipe, demo & practice file →

Fixed costs divided by margin per cover — the number of guests needed to break even.

=fixed_costs / (avg_check - variable_cost_per_cover)
Recipe, demo & practice file →

Cost of food sold divided by food sales — the headline kitchen metric (target 28–35%).

=cost_of_food_sold / food_sales
Recipe, demo & practice file →

Rooms sold divided by rooms available — the foundation hotel occupancy metric.

=rooms_sold / rooms_available
Recipe, demo & practice file →

Total payroll divided by sales — the labor half of cost control (target 25–35%).

=total_labor_cost / total_sales
Recipe, demo & practice file →

Divide plate cost by a target food cost % to set a menu price that hits your margin.

=plate_cost / target_food_cost_percent
Recipe, demo & practice file →

Gross up recipe cost by a waste rate so sold dishes carry spillage and comps.

=recipe_cost / (1 - waste_percent)
Recipe, demo & practice file →

Food plus labor cost over sales — the controllable 'prime cost' (target ~60% or less).

=(food_cost + labor_cost) / total_sales
Recipe, demo & practice file →

As-purchased cost divided by yield — the real cost of the usable portion after trim loss.

=as_purchased_cost / yield_percent
Recipe, demo & practice file →

Room revenue per available room — ADR times occupancy, the hotel headline metric.

=ADR * occupancy_rate (or) =room_revenue / rooms_available
Recipe, demo & practice file →

Each worker's hours over total hours times the pool — a fair, proportional tip split.

=worker_hours / total_hours * tip_pool
Recipe, demo & practice file →

Education & Grading

Gradebook and classroom math — weighted grades, GPA, curving, dropping scores, attendance, ranking, rubrics and mastery.

Attendance Rate

All versions

Days present over total, or COUNTIF of 'P' marks — the attendance percentage.

=COUNTIF(marks, "P") / COUNTA(marks)
Recipe, demo & practice file →

Rank grades highest-first with RANK, plus tie-broken and dense ranking add-ons.

=RANK(grade, all_grades, 0)
Recipe, demo & practice file →

Add capped points or scale to the top score — common grade-curving methods in one formula.

=MIN(score + curve_points, 100)
Recipe, demo & practice file →

Subtract the minimum and divide by n−1 — average with the worst grade dropped.

=(SUM(scores) - MIN(scores)) / (COUNT(scores) - 1)
Recipe, demo & practice file →

Credit-weighted average of grade points — the GPA, via SUMPRODUCT over points and credits.

=SUMPRODUCT(grade_points, credits) / SUM(credits)
Recipe, demo & practice file →

Rearrange the weighted-grade formula to solve for the score needed on the final.

=MAX(0, (target - current*(1 - final_weight)) / final_weight)
Recipe, demo & practice file →

Point gain and percent (and normalized) improvement from pre-test to post-test.

=post - pre // points =(post - pre) / pre // percent
Recipe, demo & practice file →

Map a numeric score to a letter with an approximate-match LOOKUP against a grade scale.

=LOOKUP(score, {0;60;70;80;90}, {"F";"D";"C";"B";"A"})
Recipe, demo & practice file →

Compare a score to a cutoff with IF — pass/fail, bands, and points-needed-to-pass.

=IF(score >= passing_score, "Pass", "Fail")
Recipe, demo & practice file →

Sum points earned over points possible for a transparent, criterion-based rubric grade.

=SUM(earned) / SUM(possible)
Recipe, demo & practice file →

Count mastered standards over total assessed — the standards-based mastery percentage.

=COUNTIF(marks, "M") / COUNTA(marks)
Recipe, demo & practice file →

Multiply each category score by its weight and sum — the weighted course grade with SUMPRODUCT.

=SUMPRODUCT(scores, weights)
Recipe, demo & practice file →

Construction & Trades

Estimating and field math — areas, material waste, concrete, paint, lumber, bid markup, labor hours, retainage and change orders.

Divide direct cost by (1 − overhead − profit) to bid for a true margin, not a markup.

=direct_cost / (1 - overhead_percent - profit_percent)
Recipe, demo & practice file →

Thickness × width (inches) × length (feet) ÷ 12 — board feet of lumber for pricing.

=thickness_in * width_in * length_ft / 12
Recipe, demo & practice file →

Change Order Total

All versions

Sum a change's direct costs, apply markup, add to the contract for the revised price.

=(labor + material + equipment) * (1 + markup)
Recipe, demo & practice file →

Length × width × thickness in feet, divided by 27 — cubic yards of concrete to order.

=ROUNDUP(length_ft * width_ft * (thickness_in / 12) / 27, 2)
Recipe, demo & practice file →

Total cost divided by finished area — the per-square-foot benchmark for budgeting.

=total_cost / square_feet
Recipe, demo & practice file →

Area plus waste, divided by box coverage, rounded up — flooring boxes to order.

=ROUNDUP(area * (1 + waste) / sqft_per_box, 0)
Recipe, demo & practice file →

Quantity over crew output for elapsed hours; times crew and wage for labor cost.

=quantity / (crew_size * units_per_worker_hour)
Recipe, demo & practice file →

Multiply needed quantity by a waste factor and round up to whole units to order.

=ROUNDUP(quantity_needed * (1 + waste_percent), 0)
Recipe, demo & practice file →

Area times coats divided by coverage per gallon, rounded up — paint gallons to buy.

=ROUNDUP(area * coats / coverage_per_gallon, 0)
Recipe, demo & practice file →

Withhold a retention percentage from each draw — net payment and held balance.

=billing_amount * (1 - retainage_percent)
Recipe, demo & practice file →

Roof area divided by 100 for squares, plus waste and bundles-per-square — shingle order.

=ROUNDUP(roof_area / 100 * (1 + waste), 2)
Recipe, demo & practice file →

Length times width in feet — the square-footage base for nearly every estimate.

=length_ft * width_ft
Recipe, demo & practice file →

Healthcare & Medical

Clinical and wellness math (educational only) — BMI, dosing, IV rates, A1C, BMR, creatinine clearance, BSA and clinic metrics.

The 28.7×A1C−46.7 conversion to estimated average glucose in mg/dL.

=28.7 * a1c - 46.7
Recipe, demo & practice file →

Missed appointments over scheduled, counted with COUNTIF — the clinic no-show rate.

=COUNTIF(status, "No-show") / COUNTA(status)
Recipe, demo & practice file →

Mifflin–St Jeor BMR times an activity factor — estimated daily calorie needs.

=(10*kg + 6.25*cm - 5*age + sex_constant) * activity_factor
Recipe, demo & practice file →

Weight over height squared (or the 703 factor for imperial) — the BMI screening ratio.

=weight_kg / height_m^2
Recipe, demo & practice file →

The Mosteller square-root formula for body surface area, for m²-based dosing.

=SQRT(height_cm * weight_kg / 3600)
Recipe, demo & practice file →

The Cockcroft–Gault estimate of kidney function from age, weight and creatinine.

=(140 - age) * kg / (72 * serum_creatinine) * sex_factor
Recipe, demo & practice file →

Patient-days over available bed-days — the hospital capacity-utilization rate.

=patient_days / (beds * days_in_period)
Recipe, demo & practice file →

Volume times drop factor over minutes — IV drops per minute for a gravity infusion.

=volume_mL * drop_factor / time_min
Recipe, demo & practice file →

Weight, height and glucose conversions (and the CONVERT function) for clinical sheets.

=pounds / 2.205
Recipe, demo & practice file →

Clark's (weight) and Young's (age) rules to estimate a child's dose from the adult dose.

=adult_dose * child_weight_lb / 150
Recipe, demo & practice file →

Max heart rate (220−age) times a zone percentage — training heart-rate targets.

=(220 - age) * zone_percent
Recipe, demo & practice file →

Dose per kilogram times body weight — the base weight-based dosing calculation.

=dose_per_kg * weight_kg
Recipe, demo & practice file →

Nonprofit & Fundraising

Development and stewardship math — donor retention, gift size, cost per dollar, ROI, LTV, matching gifts, pledges and grant budgets.

Average Gift Size

All versions

Total raised over the number of gifts — average gift, best read beside the median.

=total_raised / number_of_gifts
Recipe, demo & practice file →

Fundraising cost divided by dollars raised — the efficiency ratio (lower is better).

=fundraising_cost / dollars_raised
Recipe, demo & practice file →

Average annual giving times expected donor lifespan — donor lifetime value.

=annual_gift * expected_years
Recipe, demo & practice file →

Retained donors over prior-year donors — fundraising's key retention metric.

=donors_retained / prior_year_donors
Recipe, demo & practice file →

Raised over goal, capped at 100% — the campaign-thermometer progress percentage.

=MIN(raised / goal, 1)
Recipe, demo & practice file →

Net raised over cost — fundraising ROI, framed the way boards expect.

=(dollars_raised - cost) / cost
Recipe, demo & practice file →

Grant total times each category percent, tied out to the award — a clean grant budget.

=ROUND(grant_total * category_percent, 2)
Recipe, demo & practice file →

Donation times the match ratio, capped — matched amount and combined total.

=MIN(donation * match_ratio, match_cap)
Recipe, demo & practice file →

Dollars collected over dollars pledged — the pledge fulfillment reality check.

=amount_collected / amount_pledged
Recipe, demo & practice file →

Program expense over total expense — the program-vs-overhead efficiency ratio.

=program_expense / total_expense
Recipe, demo & practice file →

Total volunteer hours times an hourly value (or role rates) — the in-kind contribution.

=total_hours * hourly_value
Recipe, demo & practice file →

This year's donors minus last year's, over last year — the YoY growth trend.

=(donors_this_year - donors_last_year) / donors_last_year
Recipe, demo & practice file →

Freelance & Agency

Independent and agency business math — rate-setting, quoting, utilization, retainers, late fees, taxes, profitability and scope.

Billable hours over available hours — the agency/freelancer utilization metric.

=billable_hours / available_hours
Recipe, demo & practice file →

Blended Team Rate

All versions

Hours-weighted average of role rates — the blended team rate, via SUMPRODUCT.

=SUMPRODUCT(hours, rates) / SUM(hours)
Recipe, demo & practice file →

Fee times each milestone percent, final as remainder — a deposit/milestone schedule.

=ROUND(project_fee * milestone_percent, 2)
Recipe, demo & practice file →

Project fee divided by actual hours — what a fixed price really paid per hour.

=project_fee / actual_hours
Recipe, demo & practice file →

Target income plus costs over realistically billable hours — a sustainable freelance rate.

=(target_income + business_costs) / billable_hours
Recipe, demo & practice file →

Balance times rate prorated by days overdue (floored at zero) — an invoice late fee.

=balance * monthly_rate * (days_late / 30)
Recipe, demo & practice file →

Cost times one plus the markup — the client price on a fronted pass-through cost.

=cost * (1 + markup_percent)
Recipe, demo & practice file →

Profit per Client

All versions

Revenue minus cost to serve, by client with SUMIF — who's actually profitable.

=SUMIF(client, name, revenue) - SUMIF(client, name, cost)
Recipe, demo & practice file →

Estimated hours times rate, summed and buffered — a fixed-price project quote.

=SUMPRODUCT(task_hours, task_rates) * (1 + buffer)
Recipe, demo & practice file →

Income times an effective tax rate, set aside per payment — quarterly tax savings.

=ROUND(income * effective_tax_rate, 2)
Recipe, demo & practice file →

Allotment minus hours logged this period — retainer hours left, with overage flagged.

=retainer_hours - SUMIF(month, this_month, hours_logged)
Recipe, demo & practice file →

Actual hours minus budget (floored), with percent over and unbilled cost — scope creep.

=MAX(actual_hours - budget_hours, 0)
Recipe, demo & practice file →

Sales & CRM

Pipeline and revenue math — quota attainment, win rate, coverage, weighted forecast, velocity, churn, MRR/ARR, CAC and conversion.

Won revenue over won-deal count — average deal size, best read with the median.

=total_won_revenue / number_of_won_deals
Recipe, demo & practice file →

CAC Payback Period

All versions

CAC over monthly gross margin per customer — months to recoup acquisition cost.

=CAC / (monthly_revenue_per_customer * gross_margin)
Recipe, demo & practice file →

Show each rep's actual sales as a percent of quota, with status.

=Actual/Quota
Recipe, demo & practice file →

Each stage's count over the prior stage — pinpoints where the funnel leaks.

=stage_count / previous_stage_count
Recipe, demo & practice file →

Sales and marketing spend over new customers — customer acquisition cost (judge vs LTV).

=(sales_cost + marketing_cost) / new_customers
Recipe, demo & practice file →

Customers (or revenue) lost over the starting count — the subscription churn rate.

=customers_lost / customers_at_start
Recipe, demo & practice file →

Customers won over total leads — end-to-end funnel conversion, for planning demand.

=customers_won / total_leads
Recipe, demo & practice file →

Sum active monthly fees for MRR, times 12 for ARR — recurring-revenue basics.

=SUM(active_monthly_fees) // MRR =MRR * 12 // ARR
Recipe, demo & practice file →

Open pipeline over the quota gap — coverage ratio (benchmark ~1/win-rate).

=open_pipeline / quota_remaining
Recipe, demo & practice file →

Actual sales over quota — the headline sales-scorecard attainment percentage.

=actual_sales / quota
Recipe, demo & practice file →

Sales Velocity

All versions

Opps times win rate times deal size, over cycle days — revenue per day (sales velocity).

=(opportunities * win_rate * avg_deal) / cycle_length_days
Recipe, demo & practice file →

Sales Win Rate

All versions

Deals won over total closed deals — the core sales win-rate metric.

=deals_won / (deals_won + deals_lost)
Recipe, demo & practice file →

Each deal's value times its win probability, summed — the weighted sales forecast.

=SUMPRODUCT(deal_value, win_probability)
Recipe, demo & practice file →

E-commerce & Marketing

Store and campaign math — conversion, AOV, cart abandonment, ROAS, CPC/CPL, CTR, CLV, repeat rate, email rates and returns.

Revenue over orders — average order value, a direct multiplier on the top line.

=total_revenue / number_of_orders
Recipe, demo & practice file →

One over gross margin — the ROAS at which ad margin just covers spend.

=1 / gross_margin
Recipe, demo & practice file →

One minus completed over started carts — the cart abandonment rate.

=1 - completed_purchases / carts_created
Recipe, demo & practice file →

Clicks over impressions — click-through rate, the funnel's first conversion.

=clicks / impressions
Recipe, demo & practice file →

Spend per click (CPC) and per conversion (CPA) — what clicks and customers cost.

=ad_spend / clicks // CPC =ad_spend / conversions // CPA
Recipe, demo & practice file →

Cost per Lead

All versions

Marketing spend over leads generated — cost per lead (carry it through to cost per customer).

=marketing_spend / leads_generated
Recipe, demo & practice file →

AOV times frequency times lifespan (and margin) — e-commerce customer lifetime value.

=AOV * purchases_per_year * lifespan_years
Recipe, demo & practice file →

Orders over sessions — the store conversion rate (pair with AOV for revenue/visit).

=orders / sessions
Recipe, demo & practice file →

Opens and clicks over delivered (plus click-to-open) — email campaign rates.

=opens / delivered // open rate =clicks / delivered // click rate
Recipe, demo & practice file →

Refunds over orders (or dollars) — the return rate and its hit to net revenue.

=refunds / orders
Recipe, demo & practice file →

Customers with 2+ orders over total customers — the repeat purchase (loyalty) rate.

=repeat_customers / total_customers
Recipe, demo & practice file →

Ad revenue over ad spend — ROAS, judged against your margin-based break-even.

=ad_revenue / ad_spend
Recipe, demo & practice file →

Look up a shipping rate from a weight band with approximate-match VLOOKUP.

=VLOOKUP(Weight,Bands,2,TRUE)
Recipe, demo & practice file →

Fitness & Gym

Training and member math (educational only) — 1RM, plate math, pace, calories, macros, volume load, body fat and gym retention.

The Navy tape formula (LOG10 on waist, neck, height) — estimated body-fat percentage.

=495 / (1.0324 - 0.19077*LOG10(waist-neck) + 0.15456*LOG10(height)) - 450
Recipe, demo & practice file →

Find the percentage of members who cancelled this month.

=Cancelled/StartingMembers
Recipe, demo & practice file →

MET times weight (kg) times hours times 1.05 — estimated calories burned in a session.

=met * weight_kg * hours * 1.05
Recipe, demo & practice file →

Attendees over class capacity — how full gym/studio sessions run.

=attendance / capacity
Recipe, demo & practice file →

The Epley formula weight × (1 + reps/30) — estimated one-rep max from a set.

=weight * (1 + reps / 30)
Recipe, demo & practice file →

Cancellations over starting members — gym churn, retention, and average stay.

=members_cancelled / members_at_start
Recipe, demo & practice file →

Calories times macro percent over calories-per-gram (4 or 9) — macros in grams.

=ROUND(calories * protein_percent / 4, 0)
Recipe, demo & practice file →

Current weight times (1 + increment), rounded to loadable — next session's target.

=MROUND(current_weight * (1 + increment), 5)
Recipe, demo & practice file →

Time divided by distance, formatted with TEXT — running pace per mile or km.

=TEXT((total_minutes / miles) / 1440, "m:ss")
Recipe, demo & practice file →

Steps times stride over 5,280 — distance from a step count, plus rough calories.

=steps * stride_length_ft / 5280
Recipe, demo & practice file →

1RM times percent rounded to a loadable weight, plus plates per side — programming math.

=MROUND(one_rm * percent, 5)
Recipe, demo & practice file →

Sets times reps times weight, summed with SUMPRODUCT — weekly training volume load.

=SUMPRODUCT(sets, reps, weight)
Recipe, demo & practice file →

Pounds to lose over weekly loss (deficit×7/3500) — an estimated weight-loss timeline.

=pounds_to_lose / (daily_deficit * 7 / 3500)
Recipe, demo & practice file →

Automotive & Fleet

Vehicle and fleet math — MPG, cost per mile, trip fuel, lease vs buy, TCO, depreciation, reimbursement and EV-vs-gas.

Price premium over annual fuel savings — payback years on an efficiency upgrade.

=extra_cost / annual_fuel_savings
Recipe, demo & practice file →

Gas price/MPG vs kWh-per-mile times electricity price — EV vs gas cost per mile.

=gas_price / MPG // gas =kwh_per_mile * elec_price // EV
Recipe, demo & practice file →

Active vehicle-days over available vehicle-days — fleet utilization and idle capacity.

=active_days / (vehicles * days_in_period)
Recipe, demo & practice file →

Distance over MPG times fuel price — the fuel cost to plan any trip.

=distance / MPG * fuel_price
Recipe, demo & practice file →

Loan PMT vs lease depreciation plus rent charge — the monthly lease-vs-buy comparison.

=PMT(rate/12, months, -(price - down))
Recipe, demo & practice file →

Last service plus interval minus current miles — miles until the next service is due.

=last_service + interval - current_miles
Recipe, demo & practice file →

Business miles times a per-mile rate — mileage reimbursement for expense reports.

=business_miles * rate_per_mile
Recipe, demo & practice file →

Miles over gallons — fuel economy (use total/total for lifetime, not averaged ratios).

=miles_driven / gallons_used
Recipe, demo & practice file →

Approximate-match LOOKUP on cost bands times (1 + markup) — a shop parts-markup matrix.

=cost * (1 + LOOKUP(cost, cost_breaks, markup_rates))
Recipe, demo & practice file →

Depreciation plus fuel, insurance, maintenance and financing — a vehicle's true TCO.

=depreciation + fuel + insurance + maintenance + financing
Recipe, demo & practice file →

Total annual cost over annual miles — the all-in cost per mile for pricing routes.

=total_annual_cost / annual_miles
Recipe, demo & practice file →

Price times retained fraction to the power of years — a declining-balance car value.

=purchase_price * (1 - annual_rate)^years
Recipe, demo & practice file →

Events & Catering

Event and wedding planning math — catering, guest counts, bar and rental quantities, seating, budgets, vendor payments and timelines.

Guests times hours times a per-guest rate, rounded up — bar quantities to stock.

=guests * hours * drinks_per_guest_hour
Recipe, demo & practice file →

Total budget times each category percent, tied out — an event budget allocation.

=ROUND(total_budget * category_percent, 0)
Recipe, demo & practice file →

Event date minus TODAY for a live countdown, minus lead times for task due dates.

=event_date - TODAY()
Recipe, demo & practice file →

Service charge and tax compounded, plus a separate gratuity — the real event total.

=subtotal * (1 + service_charge) * (1 + tax) + subtotal * gratuity
Recipe, demo & practice file →

SUMIF of party sizes for Yes RSVPs — the true headcount, plus-ones included.

=SUMIF(rsvp, "Yes", party_size)
Recipe, demo & practice file →

COUNTIF each entrée from the RSVP list — the meal tally to give your caterer.

=COUNTIF(meal_choices, "Beef")
Recipe, demo & practice file →

Per-plate price times guest count — the catering food total to start an event budget.

=price_per_plate * guest_count
Recipe, demo & practice file →

Replies over invitations, with an acceptance-rate forecast — the RSVP projection.

=responses_received / invitations_sent
Recipe, demo & practice file →

Guests times a per-guest factor plus a buffer, rounded up — rental quantities to order.

=ROUNDUP(guests * per_guest * (1 + buffer), 0)
Recipe, demo & practice file →

Guests over seats per table, rounded up — the tables an event needs.

=ROUNDUP(guests / seats_per_table, 0)
Recipe, demo & practice file →

All-in event cost over headcount — cost per guest (the biggest lever is the list).

=total_event_cost / guest_count
Recipe, demo & practice file →

Total minus deposit (with a due date) — the vendor balance and payment schedule.

=total_cost - deposit
Recipe, demo & practice file →

Data Cleaning

Tidy messy data with formulas — standardize phones and currency, kill non-breaking spaces, split, validate, dedupe and build match keys.

Trim, clean, uppercase and de-punctuate into one canonical key — fix mismatched lookups.

=UPPER(TRIM(CLEAN(SUBSTITUTE(SUBSTITUTE(A2, CHAR(160), " "), ".", ""))))
Recipe, demo & practice file →

Strip currency symbols and commas, then VALUE — text amounts become summable numbers.

=VALUE(SUBSTITUTE(SUBSTITUTE(A2,"$",""),",",""))
Recipe, demo & practice file →

MAXIFS finds the latest date recorded for each key, then a simple comparison flags every row as Keep or Superseded, so an import with repeated updates to the same record resolves to the current version.

=IF(Date=MAXIFS(DateRange,KeyRange,Key),"Keep","Superseded")
Recipe, demo & practice file →

Pull every digit out of mixed text and hand back a real number.

=TEXTJOIN("",,IFERROR(MID(A2,SEQUENCE(LEN(A2)),1)*1,""))*1
Recipe, demo & practice file →

The text between // and the next slash — the domain pulled from a full URL.

=MID(url, FIND("//", url) + 2, FIND("/", url & "/", FIND("//", url) + 2) - FIND("//", url) - 2)
Recipe, demo & practice file →

IF blank take the value above, else keep — fill down a sparse group-label column.

=IF(A2="", B1, A2)
Recipe, demo & practice file →

A running COUNTIF that equals 1 on the first occurrence — flag firsts vs duplicates.

=IF(COUNTIF($A$2:A2, A2) = 1, "First", "Duplicate")
Recipe, demo & practice file →

TEXTJOIN with ignore-empty TRUE — join a range cleanly, with no gaps from blanks.

=TEXTJOIN(", ", TRUE, range)
Recipe, demo & practice file →

Swap CHAR(160) for a space, CLEAN, then TRIM — the fix when TRIM alone fails.

=TRIM(CLEAN(SUBSTITUTE(A2, CHAR(160), " ")))
Recipe, demo & practice file →

FIND the opening parenthesis, LEFT everything before it, TRIM the space — and append a "(" to the search text so rows with no parentheses pass through untouched.

=TRIM(LEFT(A2,FIND("(",A2&"(")-1))
Recipe, demo & practice file →

FIND the delimiter and slice with LEFT/MID (or TEXTSPLIT) — split one cell into fields.

=LEFT(A2, FIND(";", A2) - 1)
Recipe, demo & practice file →

Break 'Dallas, TX 75201' into City, State, and ZIP columns.

=LEFT(A2,FIND(",",A2)-1)
Recipe, demo & practice file →

Separate 'First Last' into two columns with classic text functions.

=LEFT(A2,FIND(" ",A2)-1)
Recipe, demo & practice file →

Strip non-digits then TEXT-format — phone numbers in one consistent layout.

=TEXT(VALUE(digits_only), "(000) 000-0000")
Recipe, demo & practice file →

Normalize case/spaces, then map affirmative variants to a clean Yes/No.

=IF(OR(UPPER(TRIM(A2))={"Y","YES","TRUE","1"}), "Yes", "No")
Recipe, demo & practice file →

IF length over N, take LEFT and add … — tidy truncation for labels and reports.

=IF(LEN(A2) > n, LEFT(A2, n) & "…", A2)
Recipe, demo & practice file →

Check for an @, a dot after it, and no spaces — a basic email format validator.

=AND(ISNUMBER(SEARCH("@", A2)), ISNUMBER(SEARCH(".", A2, SEARCH("@", A2))), ISERROR(SEARCH(" ", A2)))
Recipe, demo & practice file →

Dashboards & Reporting

Build interactive reports — dropdown-driven KPIs, status indicators, top-N lists, toggles, sparkline cues and in-cell bars.

TODAY() minus the last-updated date shows how stale a dashboard metric is, and a simple IF turns that day count into a Fresh or Stale flag so a broken data feed is visible at a glance instead of hiding behind an unchanged-looking number.

=IF(TODAY()-LastUpdate>3,"Stale","Fresh")
Recipe, demo & practice file →

A dropdown selector driving INDEX/MATCH KPIs — the core interactive-dashboard pattern.

=INDEX(metric_column, MATCH(selected, item_column, 0))
Recipe, demo & practice file →

Dynamic Top-N List

All versions

LARGE for the Nth value, INDEX/MATCH for its name — a live, auto-ranking top-N list.

=INDEX(names, MATCH(LARGE(values, n), values, 0))
Recipe, demo & practice file →

A custom number format with trailing commas — show millions as 1.2M without losing the value.

[<1000000]#,##0,"K";#,##0.0,,"M"
Recipe, demo & practice file →

REPT a block character proportional to a percent — an in-cell bar with no chart.

=REPT("█", ROUND(percent * 20, 0))
Recipe, demo & practice file →

One COUNTIF per status with totals and percentages — a live KPI status board.

=COUNTIF(status_column, "Open")
Recipe, demo & practice file →

A nested IF returning ▲/▼/● vs target — the at-a-glance KPI status indicator.

=IF(actual>target, "▲", IF(actual<target, "▼", "●"))
Recipe, demo & practice file →

Label plus TEXT-formatted NOW (captured for accuracy) — a dashboard freshness stamp.

="Last updated " & TEXT(NOW(), "mmm d, yyyy h:mm AM/PM")
Recipe, demo & practice file →

Band a metric Red/Amber/Green against thresholds with IFS — the universal status signal.

=IFS(value>=green, "Green", value>=amber, "Amber", TRUE, "Red")
Recipe, demo & practice file →

Add a cumulative running total and each row's share of the whole.

=SUM($B$2:B2) and =B2/SUM($B$2:$B$8)
Recipe, demo & practice file →

A scrollbar-driven start cell plus INDEX — page a fixed window through a long list.

=INDEX(data, start_row + k - 1)
Recipe, demo & practice file →

CHOOSE (or INDEX) on a selector cell — flip one tile or chart between metrics.

=CHOOSE(selector, revenue, units, margin)
Recipe, demo & practice file →

Compare the latest point to the prior (or an average) for a ▲/▼/▬ trend symbol.

=IF(latest>prior, "▲", IF(latest<prior, "▼", "▬"))
Recipe, demo & practice file →

Arrow by direction plus a signed-percent TEXT — a compact variance indicator.

=IF(curr>=prior, "▲ ", "▼ ") & TEXT(curr/prior-1, "+0%;-0%")
Recipe, demo & practice file →

Auditing & Error-Proofing

Make spreadsheets self-checking — reconcile lists, tie out totals, flag bad data, audit duplicates and stop errors cascading.

COUNTIF a key column > 1 flags duplicates — protect lookups and totals from repeats.

=IF(COUNTIF(key_column, A2) > 1, "Duplicate", "Unique")
Recipe, demo & practice file →

Compares the span between the smallest and largest number in a sequence against how many numbers are actually present, so a missing invoice or check number shows up as a count mismatch without listing every number by hand.

=IF((MAX(Range)-MIN(Range)+1)=COUNT(Range),"No gaps","Gap: "&(MAX(Range)-MIN(Range)+1-COUNT(Range))&" missing")
Recipe, demo & practice file →

Rounded SUM of shares = 1 (or 100) — verify an allocation adds up before trusting it.

=ROUND(SUM(percent_range), 4) = 1
Recipe, demo & practice file →

COUNTBLANK of the required range = 0 means complete — a form/import completeness check.

=IF(COUNTBLANK(required_range) = 0, "Complete", "Missing fields")
Recipe, demo & practice file →

Summary total minus the detail sum (rounded) = 0 — a self-auditing tie-out check.

=ROUND(summary_total - SUM(detail_range), 2) = 0
Recipe, demo & practice file →

SUM plus COUNTA as a fingerprint (and a weighted checksum) — verify a clean data transfer.

=SUM(amount_column) & " / " & COUNTA(id_column)
Recipe, demo & practice file →

Sum of row totals minus sum of column totals = 0 (after ROUND) — a grid integrity check.

=ROUND(SUM(row_totals) - SUM(col_totals), 2) = 0
Recipe, demo & practice file →

Wrap risky formulas in IFERROR with a fallback — stop one error cascading through totals.

=IFERROR(numerator / denominator, 0)
Recipe, demo & practice file →

ISFORMULA FALSE in a calculated range flags typed-in overrides — stop silent model decay.

=IF(ISFORMULA(A2), "OK", "Hard-coded!")
Recipe, demo & practice file →

COUNTIF against a master list = 0 flags unapproved entries — audit data already entered.

=IF(COUNTIF(allowed_list, A2) = 0, "Invalid", "OK")
Recipe, demo & practice file →

IF with OR: a transaction date before the period start or after the period end gets a flag, so a September report cannot quietly include an August invoice.

=IF(OR(Date<Start,Date>End),"Outside period","OK")
Recipe, demo & practice file →

Mark rows that are exact duplicates across several columns, not just one.

=IF(COUNTIFS(A:A,A2,B:B,B2,C:C,C2)>1,"Dup","")
Recipe, demo & practice file →

IF the value breaks min or max, flag it — a one-column data-entry validation report.

=IF(OR(A2<min, A2>max), "Out of range", "OK")
Recipe, demo & practice file →

COUNTIF each item against the other list (both ways) — find what doesn't reconcile.

=IF(COUNTIF(list_b, A2) = 0, "Missing in B", "OK")
Recipe, demo & practice file →

ABS of the difference ≤ tolerance — pass small, expected gaps without false alarms.

=ABS(value_a - value_b) <= tolerance
Recipe, demo & practice file →

Manufacturing & Operations

Shop-floor and lean math — OEE, takt, cycle time, scrap, first-pass yield, throughput, downtime, BOM builds and PPM.

Run time over units = cycle time, checked against takt — find the line's bottleneck.

=run_time / units_produced
Recipe, demo & practice file →

Defect fraction times a million — PPM, the high-precision quality measure (Six Sigma = 3.4).

=defects / total_units * 1000000
Recipe, demo & practice file →

Unplanned stop time over planned time — downtime %, the inverse of availability.

=downtime_minutes / planned_minutes
Recipe, demo & practice file →

Units passing first time over units in, multiplied across steps — rolled first-pass yield.

=units_passed_first_time / units_in
Recipe, demo & practice file →

Earned standard hours over actual hours — labor efficiency vs standard (100% = on standard).

=earned_standard_hours / actual_hours
Recipe, demo & practice file →

Availability times performance times quality — the OEE productivity score.

=availability * performance * quality
Recipe, demo & practice file →

Actual output over max capacity — production utilization for shift and capex decisions.

=actual_output / max_capacity
Recipe, demo & practice file →

Sum of MIN(actual, planned) over total planned — honest schedule attainment by item.

=SUM(MIN(actual, planned) per item) / SUM(planned)
Recipe, demo & practice file →

Defective units over total produced — the scrap rate (yield is its complement).

=defective_units / total_units
Recipe, demo & practice file →

Available time over demand — the takt pace every workstation must keep to meet demand.

=available_time / customer_demand
Recipe, demo & practice file →

Good units over hours run — throughput, and the basis for run planning and performance.

=units_produced / hours_run
Recipe, demo & practice file →

Stock over per-unit need (rounded down), then MIN — units buildable from a BOM.

=MIN(ROUNDDOWN(stock_each / qty_per_unit, 0))
Recipe, demo & practice file →

Law-firm billing and practice math — billable hours, time rounding, contingency fees, trust/IOLTA balances, realization, deadlines, and matter budgets.

ROUND(total × share, 2) with a last-row plug — allocate a combined fee so the parts tie out.

=ROUND(total_fee * matter_hours / SUM(hours), 2)
Recipe, demo & practice file →

SUMIFS the hours where matter and billable flag match — billable hours and fees per matter.

=SUMIFS(hours, matter, "Smith", billable, "Yes")
Recipe, demo & practice file →

SUMPRODUCT(hours, rates) over SUM(hours) — the hours-weighted blended attorney rate.

=SUMPRODUCT(hours, rates) / SUM(hours)
Recipe, demo & practice file →

Recovery times fee % for the fee; recovery minus fee minus costs for the client net.

=recovery*fee_pct then net = recovery - fee - costs
Recipe, demo & practice file →

WORKDAY(trigger, days, holidays) for court days; trigger+days for calendar days — court deadlines.

=WORKDAY(trigger_date, days, holidays)
Recipe, demo & practice file →

Fees to date over budget — matter burn, with projected-at-completion to catch cap overruns.

=fees_to_date / matter_budget
Recipe, demo & practice file →

Billed over worked value — realization, the share of effort that becomes billed (and collected) money.

=billed_value / worked_value
Recipe, demo & practice file →

IF(balance < floor, target - balance, 0) — the retainer top-up needed to refill to target.

=IF(balance < floor, target - balance, 0)
Recipe, demo & practice file →

CEILING(minutes/60, 0.1) — round raw minutes up to the next billable tenth of an hour.

=CEILING(minutes/60, 0.1)
Recipe, demo & practice file →

EDATE(accrual, years*12) — the statute-of-limitations bar date, with an early-warning countdown.

=EDATE(accrual_date, years*12)
Recipe, demo & practice file →

Per-client deposits minus disbursements via SUMIFS — trust/IOLTA balances that never go negative.

=SUMIFS(amount, client, "Lee", type, "Deposit") - SUMIFS(amount, client, "Lee", type, "Disbursement")
Recipe, demo & practice file →

Worked value minus write-down for the net bill; billed minus write-off for net receivable.

=worked_value - write_down
Recipe, demo & practice file →

Agriculture & Farming

Farm and ranch math — crop yield, seeding and fertilizer rates, feed rations, herd inventory, break-even price, irrigation, stocking rate, gross margin, grain shrink, and gestation dates.

Cost per acre over yield per acre — the break-even price each bushel must clear.

=cost_per_acre / yield_per_acre
Recipe, demo & practice file →

Breeding date plus gestation length — projected calving/farrowing due dates with a countdown.

=breeding_date + gestation_days
Recipe, demo & practice file →

Total harvest over acres — yield per acre, the basis for revenue and field comparison.

=total_harvest / acres
Recipe, demo & practice file →

Target nutrient over the analysis fraction — pounds of fertilizer product per acre.

=target_N_lbs / (N_percent/100)
Recipe, demo & practice file →

Revenue per acre minus variable cost per acre — gross margin to rank crop enterprises.

=revenue_per_acre - variable_cost_per_acre
Recipe, demo & practice file →

Wet weight scaled by the dry-matter ratio — dry-weight grain at market moisture, and shrink.

=wet_weight * (100 - wet_moisture) / (100 - target_moisture)
Recipe, demo & practice file →

Opening plus births and purchases minus deaths and sales — the closing herd count.

=opening + births + purchases - deaths - sales
Recipe, demo & practice file →

Acres times inches for acre-inches; ×27,154 for gallons — the irrigation water requirement.

=acres * inches_applied
Recipe, demo & practice file →

Head times daily ration for feed per day; inventory over daily for days of supply.

=head_count * lbs_per_head_per_day
Recipe, demo & practice file →

Ownership plus operating cost over acres covered — machinery cost each acre carries.

=(ownership_cost + operating_cost) / acres_per_year
Recipe, demo & practice file →

Rate times acres, divided by bag size and rounded up — total seed and bags to buy.

=seeding_rate * acres
Recipe, demo & practice file →

Animal units over acres — stocking rate, matching grazing pressure to pasture.

=total_animal_units / acres
Recipe, demo & practice file →

Salon, Spa & Beauty

Salon, spa, and barbershop math — pay models, service and color costing, chair utilization, rebooking and retention, average ticket, tips, no-shows, and gift-card liability.

Total revenue over clients served — average ticket, the spend per visit to grow.

=total_revenue / client_count
Recipe, demo & practice file →

Revenue minus rent vs revenue times commission — compare salon pay models and break-even.

=service_revenue - booth_rent vs service_revenue * commission_pct
Recipe, demo & practice file →

Booked hours over available hours — chair/room utilization and the cost of idle capacity.

=booked_hours / available_hours
Recipe, demo & practice file →

Returning clients over eligible — retention, with new-client retention as the growth metric.

=returned_clients / total_clients
Recipe, demo & practice file →

Grams used times cost per gram (tube price ÷ tube grams) — exact color cost per service.

=grams_used * cost_per_gram
Recipe, demo & practice file →

Cards sold minus redeemed — outstanding gift-card liability, recognized as revenue on use.

=total_sold - total_redeemed
Recipe, demo & practice file →

No-shows over booked appointments — the no-show rate and the revenue it costs.

=no_shows / booked_appointments
Recipe, demo & practice file →

Rebooking Rate

All versions

Rebooked clients over total served — rebooking rate, the best leading indicator of retention.

=rebooked / total_clients
Recipe, demo & practice file →

Retail sales over service sales — the retail-to-service ratio, a measure of product selling.

=retail_sales / service_sales
Recipe, demo & practice file →

Service revenue over hours worked — stylist revenue per hour, normalized for schedule.

=service_revenue / hours_worked
Recipe, demo & practice file →

Price minus product cost for service margin; cost over (1−target) to price for a margin.

=service_price - product_cost
Recipe, demo & practice file →

ROUND(pool × share, 2) with a last-person plug — split a tip pool so the parts tie out.

=ROUND(pool * hours / SUM(hours), 2)
Recipe, demo & practice file →

Photography & Creative

Photography and creative-services math — CODB rate, session and print pricing, packages, shoot-to-edit time, storage, licensing tiers, travel billing, deposits, second shooters, and revenue per shoot.

Base price plus MAX(extra spreads, 0) times the per-spread rate — album pricing.

=base_price + MAX(spreads - included, 0) * per_spread
Recipe, demo & practice file →

Costs plus salary over billable hours — the CODB rate that keeps a creative business solvent.

=(annual_costs + target_salary) / billable_hours
Recipe, demo & practice file →

Total times deposit % for the retainer; total minus deposit for the balance, installments plugged.

=ROUND(total * deposit_pct, 2)
Recipe, demo & practice file →

Base fee times a usage-tier multiplier via VLOOKUP — license fees that scale with usage.

=base_fee * VLOOKUP(usage, tier_table, 2, FALSE)
Recipe, demo & practice file →

SUMPRODUCT item value times (1 − discount) — build and price photography packages.

=SUMPRODUCT(qty, price) * (1 - bundle_discount)
Recipe, demo & practice file →

Lab cost times the markup multiple for retail; margin = 1 − 1/multiple.

=lab_cost * markup_multiple
Recipe, demo & practice file →

Total revenue over shoots — average per shoot, split by type to find what builds the business.

=total_revenue / shoots
Recipe, demo & practice file →

Second-shooter hours times their rate, netted against added revenue — does the help pay off?

=hours * second_shooter_rate
Recipe, demo & practice file →

Session price minus all costs for profit; divide by hours to compare bookings fairly.

=session_price - total_costs
Recipe, demo & practice file →

Shoot hours times the edit ratio — total project time so editing labor gets priced in.

=shoot_hours * edit_ratio
Recipe, demo & practice file →

Frames times file size over 1024 for GB per shoot; times copies for real drive needs.

=frames * file_size_mb / 1024
Recipe, demo & practice file →

MAX(miles − free radius, 0) times the per-mile rate — billable travel beyond a free zone.

=MAX(round_trip_miles - free_radius, 0) * rate_per_mile
Recipe, demo & practice file →

Divide a shoot fee by all the hours it really takes.

=Fee/(ShootHrs+EditHrs+AdminHrs)
Recipe, demo & practice file →

Property Management

Property and rental management math — prorated rent, late fees, management fees, occupancy, rent rolls, deposits, CAM reconciliation, escalations, tenant screening, lease tracking, and turnover cost.

Total CAM times the tenant's sqft share, trued up against estimates — CAM reconciliation.

=total_cam * tenant_sqft / total_sqft
Recipe, demo & practice file →

Collected rent over gross potential — economic occupancy, versus the physical door count.

=rent_collected / gross_potential_rent
Recipe, demo & practice file →

IF(days late > grace, fee, 0) — rent late fees with grace, percent, per-day, and caps.

=IF(days_late > grace, fee, 0)
Recipe, demo & practice file →

Lease end minus today — days to expiration, flagged into renewal windows to avoid surprise vacancies.

=lease_end - TODAY()
Recipe, demo & practice file →

Total maintenance over units — cost per unit, broken out by category to find the money pits.

=total_maintenance / unit_count
Recipe, demo & practice file →

Collected rent times the management rate — the property manager's fee, with minimums.

=rent_collected * mgmt_pct
Recipe, demo & practice file →

Monthly rent over days in month times days occupied — prorated move-in/move-out rent.

=monthly_rent / days_in_month * days_occupied
Recipe, demo & practice file →

Base rent times (1 + rate)^years — compounded annual rent escalation over a lease term.

=base_rent * (1 + annual_increase)^years
Recipe, demo & practice file →

SUMIF occupied rent, COUNTIF vacancies, AVERAGEIF by type — rent-roll totals and summaries.

=SUMIF(status, "Occupied", rent)
Recipe, demo & practice file →

Deposit minus itemized deductions — security-deposit refund, or the balance the tenant owes.

=deposit - SUM(deductions)
Recipe, demo & practice file →

Rent over gross income — the rent-to-income ratio, with the income multiple as its inverse.

=monthly_rent / monthly_income
Recipe, demo & practice file →

Lost rent for vacant days plus make-ready — the true cost of a unit turnover.

=days_vacant/30 * monthly_rent + turnover_cost
Recipe, demo & practice file →

Insurance

Insurance math — claim payouts, coinsurance, loss and combined ratios, premium proration, agent commission, deductible trade-offs, ACV depreciation, sublimits, experience mods, and life-insurance needs.

Premium times the commission rate — agent commission, with new vs renewal rates.

=premium * commission_rate
Recipe, demo & practice file →

Loss minus deductible, floored at zero and capped at the limit — the insurance payout.

=MIN(MAX(loss - deductible, 0), policy_limit)
Recipe, demo & practice file →

Loss times carried-over-required coverage (capped at 1) — the coinsurance underinsurance penalty.

=loss * (coverage_carried / (value * coinsurance_pct)) - deductible
Recipe, demo & practice file →

Combined Ratio

All versions

Claims plus expenses over earned premium — combined ratio, underwriting profit below 100%.

=(claims + expenses) / premiums_earned
Recipe, demo & practice file →

Extra deductible over annual premium saving — claim-free years to break even on a higher deductible.

=extra_deductible / annual_premium_savings
Recipe, demo & practice file →

Manual premium times the EMR — experience-mod impact, a credit below 1.0 or surcharge above.

=manual_premium * experience_mod
Recipe, demo & practice file →

Debt + income×years + mortgage + education, minus existing coverage — DIME life-insurance need.

=debt + income*years + mortgage + education
Recipe, demo & practice file →

Loss Ratio

All versions

Claims incurred over premiums earned — loss ratio, the core underwriting metric.

=claims_incurred / premiums_earned
Recipe, demo & practice file →

Annual premium over 12 plus the installment fee — monthly premium and the convenience surcharge.

=ROUND(annual_premium/12 + installment_fee, 2)
Recipe, demo & practice file →

Loss capped at the sublimit, then the policy limit — covered amount under layered caps.

=MIN(loss, sublimit)
Recipe, demo & practice file →

Premium times days remaining over 365 — pro-rata refund, with a short-rate penalty option.

=annual_premium * days_remaining / 365
Recipe, demo & practice file →

Replacement cost times remaining-life fraction — actual cash value after depreciation.

=replacement_cost * (1 - age / useful_life)
Recipe, demo & practice file →

Logistics & Trucking

Trucking and freight math — revenue and cost per mile, deadhead, fuel surcharge, dimensional weight, freight density, load profit, driver pay, hours of service, on-time delivery, capacity, and detention.

Find what share of miles are driven empty (unpaid).

=EmptyMiles/TotalMiles
Recipe, demo & practice file →

Total operating costs over miles — cost per mile, the break-even rate floor.

=total_operating_costs / total_miles
Recipe, demo & practice file →

Empty miles over total miles — deadhead percentage, the empty-mile efficiency metric.

=empty_miles / total_miles
Recipe, demo & practice file →

MAX(hours waited − free, 0) times the rate — detention pay for waiting past free time.

=MAX(hours_waited - free_hours, 0) * hourly_rate
Recipe, demo & practice file →

MAX of actual weight and volume-over-divisor — billable dimensional weight for freight.

=MAX(actual_weight, L*W*H / dim_divisor)
Recipe, demo & practice file →

Miles times CPM vs load revenue times percent — compare driver pay models and break-even.

=miles * cpm_rate vs load_revenue * percent
Recipe, demo & practice file →

Weight over cubic feet — freight density, the main driver of LTL class.

=weight_lb / (L*W*H / 1728)
Recipe, demo & practice file →

Fuel over peg divided by MPG — the per-mile fuel surcharge passed to the shipper.

=MAX(fuel_price - base_peg, 0) / mpg
Recipe, demo & practice file →

MIN of the 11-hour drive and 14-hour duty limits — HOS drive time remaining.

=MIN(11 - hours_driven, 14 - hours_on_duty)
Recipe, demo & practice file →

Load revenue minus all costs — load profit, compared across loads as profit per mile.

=load_revenue - total_load_costs
Recipe, demo & practice file →

On-time deliveries over total — on-time delivery rate, the core carrier service metric.

=on_time_deliveries / total_deliveries
Recipe, demo & practice file →

Revenue per Mile

All versions

Load revenue over miles — revenue per mile, the headline trucking rate.

=load_revenue / miles
Recipe, demo & practice file →

The greater of weight % and cube % — trailer utilization and whether you weigh or cube out.

=MAX(weight_used/weight_cap, cube_used/cube_cap)
Recipe, demo & practice file →

Veterinary & Pet Care

Veterinary and pet-care math — weight-based dosing, fluid rates, CRI, anesthesia monitoring, pet age, boarding billing, vaccine reminders, surgery inventory, slot revenue, compliance, medication pricing, and grooming.

Start time plus interval-as-day-fraction times reading number — anesthesia monitoring timeline.

=start_time + interval_minutes/1440 * n
Recipe, demo & practice file →

Nights between dates times the nightly rate, plus add-ons and discounts — boarding invoice.

=(checkout_date - checkin_date) * nightly_rate
Recipe, demo & practice file →

Dose/kg/hr times weight times hours, over concentration — drug to add for a CRI.

=dose_per_kg_hr * weight_kg * hours / drug_conc
Recipe, demo & practice file →

Dose per kg times weight, over concentration — drug dose and volume to administer.

=dose_mg_per_kg * weight_kg
Recipe, demo & practice file →

VLOOKUP a size-to-price table plus add-ons — grooming price by breed size.

=VLOOKUP(size, price_table, 2, TRUE)
Recipe, demo & practice file →

Daily volume over 24 for mL/hr; times drip factor over 60 for drops per minute.

=daily_ml / 24
Recipe, demo & practice file →

Cost times markup plus a dispensing fee, floored at a minimum — client medication price.

=MAX(cost*markup + dispensing_fee, minimum_price)
Recipe, demo & practice file →

A front-loaded IF model — pet age in human years, far better than the ×7 myth.

=IF(pet_years<=2, pet_years*10.5, 21 + (pet_years-2)*per_year)
Recipe, demo & practice file →

Completed follow-ups over recommended — recheck compliance, a health and revenue metric.

=completed / recommended
Recipe, demo & practice file →

Revenue over available slots — revenue per slot, split against per-booked to find the fix.

=total_revenue / available_slots
Recipe, demo & practice file →

Stock over per-procedure usage (rounded down), then MIN — procedures your supplies allow.

=MIN(ROUNDDOWN(stock / per_procedure, 0))
Recipe, demo & practice file →

Last dose date plus the interval via EDATE — vaccine booster due dates and reminders.

=EDATE(last_dose, interval_months)
Recipe, demo & practice file →

Childcare & Daycare

Childcare and daycare math — staff ratios, tuition by age, sibling discounts, late fees, enrollment, proration, subsidies, attendance, food-program reimbursement, waitlist conversion, registration, and cost per child.

Attendance Rate

All versions

Days present over enrolled days — attendance rate, feeding ratios, meals, and subsidies.

=days_present / enrolled_days
Recipe, demo & practice file →

Calculate required staff and flag rooms that are short.

=ROUNDUP(Children/MaxRatio,0)
Recipe, demo & practice file →

Total operating cost over enrolled children — cost per child, the tuition break-even benchmark.

=total_operating_cost / enrolled_children
Recipe, demo & practice file →

Enrolled over licensed capacity — enrollment utilization and the value of open slots.

=enrolled / licensed_capacity
Recipe, demo & practice file →

SUMPRODUCT of meal counts and per-meal rates — CACFP food-program reimbursement.

=SUMPRODUCT(meal_counts, meal_rates)
Recipe, demo & practice file →

Late Pickup Fee

All versions

MAX(minutes late − grace, 0) times the rate — late pickup fees, per minute or per block.

=MAX(minutes_late - grace, 0) * per_minute
Recipe, demo & practice file →

Registration fee plus deposit weeks times weekly tuition — total due at enrollment.

=registration_fee + deposit_weeks * weekly_tuition
Recipe, demo & practice file →

Full tuition for one child, discounted for the rest — the sibling/multi-child discount.

=oldest_tuition + others_tuition*(1 - sibling_discount)
Recipe, demo & practice file →

Children over the ratio, rounded up — staff required, with a compliance check.

=ROUNDUP(children / ratio, 0)
Recipe, demo & practice file →

Tuition minus the capped subsidy — the family copay split for childcare assistance.

=MAX(tuition - MIN(subsidy_max, tuition), 0)
Recipe, demo & practice file →

Weekly tuition over scheduled days times days attended — prorated childcare tuition.

=weekly_tuition / scheduled_days * days_attended
Recipe, demo & practice file →

VLOOKUP an age-group rate table, scaled by schedule — childcare tuition by age.

=VLOOKUP(age_group, rate_table, 2, FALSE)
Recipe, demo & practice file →

Enrolled over offered — waitlist conversion, and the offers needed to fill openings.

=enrolled / offered
Recipe, demo & practice file →

Dental Practice

Dental practice math — insurance estimates, patient out-of-pocket, annual maximums, production and collection, daily goals, operatory utilization, case acceptance, hygiene recare, PPO write-offs, financing, broken appointments, and supply costs.

Annual maximum minus benefit used — remaining dental benefit, capping new claims.

=annual_maximum - benefit_used
Recipe, demo & practice file →

Open chair hours times production per hour — the cost of broken appointments, annualized.

=hours_open * production_per_hour
Recipe, demo & practice file →

Treatment dollars accepted over presented — case acceptance, a conversion metric.

=dollars_accepted / dollars_presented
Recipe, demo & practice file →

Full fee minus PPO allowed fee — the contractual write-off and effective plan discount.

=full_fee - allowed_fee
Recipe, demo & practice file →

Patients with a future visit over active patients — hygiene recare and reactivation.

=patients_scheduled / active_patients
Recipe, demo & practice file →

Allowed fee minus deductible, times coverage % — the dental insurance estimate.

=(allowed_fee - deductible) * coverage_pct
Recipe, demo & practice file →

Booked over available chair hours — operatory utilization and the cost of idle chairs.

=booked_hours / available_hours
Recipe, demo & practice file →

Fee minus the estimated insurance payment — the patient's out-of-pocket portion.

=fee - estimated_insurance_payment
Recipe, demo & practice file →

Collections over production — the collection ratio, a dental practice's cash-health metric.

=collections / production
Recipe, demo & practice file →

Overhead plus profit over clinical days — the provider's daily production goal.

=(annual_overhead + profit_target) / clinical_days
Recipe, demo & practice file →

SUMPRODUCT of quantities and unit costs — supply cost per procedure and its fee percentage.

=SUMPRODUCT(quantities, unit_costs)
Recipe, demo & practice file →

PMT on the financed amount — the monthly payment for a financed treatment plan.

=PMT(rate/12, months, -amount_financed)
Recipe, demo & practice file →

Cleaning & Janitorial

Cleaning and janitorial math — square-footage bids, production rates, burdened labor and supply costs, recurring vs one-time pricing, route hours, margins, per-fixture quotes, crew sizing, chemical dilution, and account churn.

Total volume over (ratio + 1) — concentrate needed for a cleaning dilution.

=total_ounces / (ratio + 1)
Recipe, demo & practice file →

Cleanable square feet times the per-sqft rate — a fast commercial cleaning bid.

=square_feet * rate_per_sqft
Recipe, demo & practice file →

Labor hours over the window, rounded up — crew size to finish on time.

=ROUNDUP(labor_hours / window_hours, 0)
Recipe, demo & practice file →

Hours times the burdened wage — true cleaning labor cost, the core of any bid.

=hours * wage * (1 + burden_rate)
Recipe, demo & practice file →

SUMPRODUCT of room/fixture counts and rates — a per-fixture cleaning quote.

=SUMPRODUCT(counts, rates)
Recipe, demo & practice file →

Square feet over the production rate — cleaning hours, the basis of an accurate bid.

=square_feet / sqft_per_hour
Recipe, demo & practice file →

Cost over (1 − target margin) — the bid price that guarantees your cleaning margin.

=total_cost / (1 - target_margin)
Recipe, demo & practice file →

Accounts lost over starting accounts — recurring-account churn and retention.

=accounts_lost / accounts_start
Recipe, demo & practice file →

One-time price less the recurring discount — per-visit and annual recurring value.

=onetime_price * (1 - recurring_discount)
Recipe, demo & practice file →

Sum of cleaning and drive time across stops — total route hours vs the shift.

=SUM(clean_times) + SUM(drive_times)
Recipe, demo & practice file →

SUMPRODUCT of supply quantities and unit costs — supplies cost per cleaning job.

=SUMPRODUCT(quantities, unit_costs)
Recipe, demo & practice file →

Daily travel cost spread across jobs — travel-time allocation into each bid.

=daily_travel_cost / jobs_today
Recipe, demo & practice file →

Landscaping & Lawn Care

Landscaping and lawn-care math — mulch and gravel volume, mowing and snow pricing, fertilizer and sod by area, plant spacing, irrigation runtime, equipment cost, route density, contract proration, and paver counts.

Ownership over annual hours plus operating cost — the all-in equipment hourly rate.

=ownership_cost/annual_hours + operating_per_hour
Recipe, demo & practice file →

Area in thousands of square feet times the per-1,000 rate — lawn fertilizer or seed pounds.

=sqft/1000 * lbs_per_1000
Recipe, demo & practice file →

Cubic yards times tons-per-yard density — gravel and stone tonnage to order.

=cubic_yards * tons_per_yard
Recipe, demo & practice file →

Target depth over precip rate times 60 — sprinkler zone runtime in minutes.

=target_inches / precip_rate_in_hr * 60
Recipe, demo & practice file →

Mowing time times rate, floored at a minimum — the price per lawn.

=MAX(minutes/60 * hourly_rate, minimum_charge)
Recipe, demo & practice file →

Area times depth in feet over 27 — cubic yards of mulch, soil, or compost.

=sqft * depth_inches/12 / 27
Recipe, demo & practice file →

Area plus waste over paver coverage, plus base and sand by volume — patio material counts.

=ROUNDUP(area_sqft * (1+waste) / paver_sqft, 0)
Recipe, demo & practice file →

Area over spacing squared — plant count for ground cover, with a triangular-spacing option.

=area_sqft / (spacing_ft ^ 2)
Recipe, demo & practice file →

Drive hours over total route hours — drive-time share, the key to route profitability.

=drive_hours / (drive_hours + work_hours)
Recipe, demo & practice file →

Monthly rate times months remaining — seasonal lawn-contract proration.

=annual_total / total_months * remaining_months
Recipe, demo & practice file →

Base price times a depth-tier multiplier via VLOOKUP — per-push snow removal pricing.

=base_price * VLOOKUP(inches, tier_table, 2, TRUE)
Recipe, demo & practice file →

Area plus waste over coverage per piece, rounded up — sod pieces (and pallets) to order.

=ROUNDUP(sqft * (1 + waste) / piece_sqft, 0)
Recipe, demo & practice file →

Pool & Spa Service

Pool and spa service math — volume in gallons, chlorine/acid/salt/stabilizer dosing, turnover and flow, heating energy, route pricing, chemical cost, water balance (LSI), and filter cycles.

SUMPRODUCT of chemical amounts and unit costs — chemical cost per service stop.

=SUMPRODUCT(amounts, unit_costs)
Recipe, demo & practice file →

Volume in 10,000s times ppm increase times the product constant — chlorine dose to raise FC.

=gallons/10000 * ppm_increase * 10.7
Recipe, demo & practice file →

Install date plus cycle minus today — days to filter media replacement, plus a pressure trigger.

=install_date + cycle_months*30 - TODAY()
Recipe, demo & practice file →

Gallons moved over minutes — pool flow rate in GPM.

=gallons / minutes
Recipe, demo & practice file →

Per-stop cost times monthly visits, marked up to margin — pool service route pricing.

=(labor_per_stop + chem_per_stop) * visits_per_month / (1 - margin)
Recipe, demo & practice file →

Volume times pH drop times an acid constant — muriatic acid to lower pH.

=gallons/10000 * ph_drop * acid_per_10k
Recipe, demo & practice file →

Gallons times 8.34 times the degree rise — BTUs to heat a pool, and the runtime and cost.

=gallons * 8.34 * temp_rise
Recipe, demo & practice file →

Length times width times average depth times 7.48 — pool volume in gallons.

=length * width * avg_depth * 7.48
Recipe, demo & practice file →

ppm gap times volume over a constant (floored at zero) — salt to add for a target ppm.

=MAX(target_ppm - current_ppm, 0) * gallons / 120000
Recipe, demo & practice file →

CYA ppm gap times volume over a constant — cyanuric acid stabilizer to add.

=MAX(target_cya - current_cya, 0) * gallons / 120000
Recipe, demo & practice file →

Volume over GPM over 60 — pool turnover hours and daily pump runtime.

=gallons / flow_rate_gpm / 60
Recipe, demo & practice file →

Nested IF on the saturation index — flag pool water as scaling, balanced, or corrosive.

=IF(LSI > 0.3, "Scaling", IF(LSI < -0.3, "Corrosive", "Balanced"))
Recipe, demo & practice file →

HVAC & Field Service

HVAC and field-service math — cooling load and airflow, refrigerant charge, flat-rate vs T&M, service-call billing, SEER payback, maintenance agreements, first-time fix, billable efficiency, warranty recovery, dispatch cost, and degree-day fuel.

Conditioned area over sqft-per-ton — a quick AC tonnage estimate (12,000 BTU/ton).

=sqft / sqft_per_ton
Recipe, demo & practice file →

Fuel-per-degree-day times forecast HDD — projected heating fuel use and cost.

=fuel_per_hdd * forecast_hdd
Recipe, demo & practice file →

Drive labor plus vehicle cost — dispatch cost per call, the floor under the trip charge.

=drive_hours*burdened_wage + miles*cost_per_mile
Recipe, demo & practice file →

Tons times CFM-per-ton (~400) — required system airflow for duct and blower sizing.

=tons * cfm_per_ton
Recipe, demo & practice file →

First-visit fixes over total jobs — first-time fix rate, the field-service efficiency metric.

=fixed_first_visit / total_jobs
Recipe, demo & practice file →

Flat book price vs hours times rate plus parts — compare HVAC pricing models.

=flat_rate vs hours*rate + parts
Recipe, demo & practice file →

Visits times per-visit cost, marked up to margin — HVAC maintenance agreement pricing.

=visits_per_year * cost_per_visit / (1 - margin)
Recipe, demo & practice file →

Factory charge plus extra-length adder — refrigerant charge for a longer line set.

=factory_charge + MAX(line_ft - baseline_ft, 0) * oz_per_ft
Recipe, demo & practice file →

Old cost times (1 − old/new SEER) — annual SEER savings and the upgrade payback.

=old_cost * (1 - old_seer/new_seer)
Recipe, demo & practice file →

Diagnostic fee plus labor and parts — service call billing, with the diagnostic credited on approval.

=diagnostic_fee + labor + parts
Recipe, demo & practice file →

Billed hours over paid hours — technician billable efficiency, the labor-profit lever.

=billed_hours / paid_hours
Recipe, demo & practice file →

Warranty allowance over actual labor cost — recovery rate, often a loss on labor.

=warranty_allowance / actual_labor_cost
Recipe, demo & practice file →

Food Truck & Brewery

Food-truck and brewery math — event break-even, food cost %, recipe scaling, keg economics, ABV and IBU, brewhouse efficiency, batch yield, fuel and overhead, revenue per tap, and waste cost.

Gravity drop (OG − FG) times 131.25 — alcohol by volume from a brew.

=(OG - FG) * 131.25
Recipe, demo & practice file →

Actual over potential gravity points — brewhouse efficiency for grain-bill sizing.

=actual_gravity_points / potential_points
Recipe, demo & practice file →

Net ounces over can size, rounded down — sellable cans (or servings) per batch.

=ROUNDDOWN(net_gallons * 128 / can_ounces, 0)
Recipe, demo & practice file →

Annual fixed costs over operating days — the overhead each day must clear.

=annual_fixed_costs / operating_days
Recipe, demo & practice file →

Event fixed cost over contribution per cover — break-even customers for a food-truck event.

=event_fixed_cost / (avg_ticket - variable_cost)
Recipe, demo & practice file →

Alpha acid times ounces times utilization times 7489 over gallons — hop IBU estimate.

=alpha_acid * oz * utilization * 7489 / volume_gal
Recipe, demo & practice file →

Keg cost over pints per keg — cost per pint and pour profit for draft beer.

=keg_cost / pints_per_keg
Recipe, demo & practice file →

Plate cost over menu price — food cost %, with target-based pricing.

=plate_cost / menu_price
Recipe, demo & practice file →

Burn rate times service hours times price — propane/fuel cost per food-truck event.

=burn_rate_gph * service_hours * price_per_gallon
Recipe, demo & practice file →

Ingredient amount times target-over-recipe yield — scale any recipe to any batch.

=ingredient_amount * (target_yield / recipe_yield)
Recipe, demo & practice file →

Wasted units times unit cost — spoilage and waste cost, plus the waste rate to cut.

=wasted_units * unit_cost
Recipe, demo & practice file →

Total draft revenue over taps — revenue per tap to manage the lineup.

=total_tap_revenue / number_of_taps
Recipe, demo & practice file →

Barber & Tattoo Studio

Barber, tattoo, and beauty-studio math — hourly tattoo pricing, deposits and no-shows, supply cost, chair-rent break-even, tip-outs, and monthly chair revenue and occupancy.

Weekly rent over profit per cut — haircuts to break even on a rented chair.

=weekly_rent / (price - supply_cost)
Recipe, demo & practice file →

Subtract a paid deposit from the quoted price to get the balance due.

=quoted_price-deposit_paid
Recipe, demo & practice file →

IF showed credit the balance, else keep it — deposit forfeiture on a no-show.

=IF(showed, "credit balance", "forfeit")
Recipe, demo & practice file →

Appointments times average ticket, plus booked-over-available occupancy — chair output.

=appointments * avg_ticket
Recipe, demo & practice file →

Share a barber's tips with assistants and front desk by percentage.

=Tips*Percent
Recipe, demo & practice file →

SUMPRODUCT of disposable quantities and unit costs — supply cost per tattoo session.

=SUMPRODUCT(quantities, unit_costs)
Recipe, demo & practice file →

Hours times the hourly rate, floored at the shop minimum — tattoo pricing.

=MAX(hours * hourly_rate, shop_minimum)
Recipe, demo & practice file →

Tips times the tip-out percentage, rounded — the apprentice/assistant tip-out.

=ROUND(tips * tipout_pct, 2)
Recipe, demo & practice file →

Coffee Shop & Cafe

Add up cup, lid, and sleeve to cost the packaging behind every drink.

=SUM(Cup:Sleeve)
Recipe, demo & practice file →

Find how many shots a bag of beans yields from your dose.

=ROUNDDOWN(BagGrams/DoseGrams,0)
Recipe, demo & practice file →

Find the ingredient cost as a percent of a drink's menu price.

=Cost/Price
Recipe, demo & practice file →

Turn a per-gallon milk price into the milk cost in a single drink.

=ROUND(oz_per_drink/128*price_per_gallon,2)
Recipe, demo & practice file →

Work out the effective discount a 'buy 9, get the 10th free' card gives.

=1/(buys_before_free+1)
Recipe, demo & practice file →

Auto Repair Shop

Divide labor revenue by hours billed to find your real labor rate.

=LaborRevenue/HoursBilled
Recipe, demo & practice file →

Charge a percent of labor for shop supplies, capped at a maximum.

=MIN(Cap,Labor*Percent)
Recipe, demo & practice file →

Compare parts revenue to labor revenue to gauge your shop's job mix.

=parts_revenue/labor_revenue
Recipe, demo & practice file →

Compare flat-rate billed hours to actual clock hours per tech.

=BilledHours/ActualHours
Recipe, demo & practice file →

Measure repeat repairs as a percentage of total repair orders.

=comebacks/total_ROs
Recipe, demo & practice file →

Bakery

Add a number of minutes to a clock time to find when proofing ends.

=start_time+minutes/1440
Recipe, demo & practice file →

Divide batch dough weight by scoop size to count cookies, rounded down.

=ROUNDDOWN(DoughGrams/ScoopGrams,0)
Recipe, demo & practice file →

Base design fee plus servings times per-serving rate, plus optional delivery.

=Base+Servings*PerServing+IF(Del="Yes",Fee,0)
Recipe, demo & practice file →

Charge the single-item price under a dozen, the lower each-price at a dozen or more.

=Qty*IF(Qty>=12,DozenEach,SingleEach)
Recipe, demo & practice file →

Back out the flour weight from total dough and the formula percentage.

=ROUND(Dough/(TotalPct/100),0)
Recipe, demo & practice file →

Express water as a percentage of flour weight — the baker's hydration ratio.

=water_weight/flour_weight
Recipe, demo & practice file →

Divide total dough weight by the weight per piece to get whole units.

=INT(batch_weight/weight_per_unit)
Recipe, demo & practice file →

Print Shop

Find how many press sheets a job needs when several pieces print per sheet.

=ROUNDUP(pieces/up_per_sheet,0)
Recipe, demo & practice file →

Divide total job cost by the number of prints to get a per-piece cost.

=total_cost/prints
Recipe, demo & practice file →

Scale a full-coverage ink cost down by the page's ink coverage.

=full_coverage_cost*coverage_pct
Recipe, demo & practice file →

Convert a sheet count into whole reams to pull, rounded up.

=ROUNDUP(TotalSheets/500,0)
Recipe, demo & practice file →

Convert booklet pages into folded sheets, four pages per sheet.

=ROUNDUP(Pages/4,0)
Recipe, demo & practice file →

Combine a one-time setup charge with a per-piece price for a total quote.

=setup+per_unit*quantity
Recipe, demo & practice file →

Moving & Storage

Turn cubic feet into man-hours, then into hours on site for a crew.

=cubic_feet*hours_per_cuft/crew_size
Recipe, demo & practice file →

Convert cubic feet to estimated weight, then price the move per pound.

=cubic_feet*7
Recipe, demo & practice file →

Divide total volume by truck capacity and round up to whole trips.

=ROUNDUP(Volume/TruckCapacity,0)
Recipe, demo & practice file →

Multiply rented units by the average rate for monthly revenue.

=UnitsRented*AvgRate
Recipe, demo & practice file →

Pest Control

Initial service plus follow-up visits times the visit rate — yearly value.

=Initial+Visits*PerVisit
Recipe, demo & practice file →

Work out how much concentrate to add for a tank of a given size.

=TankGallons*OzPerGallon
Recipe, demo & practice file →

Turn an annual service plan into the real cost of each visit.

=AnnualPrice/Treatments
Recipe, demo & practice file →

Add a service interval to the last visit to schedule the next one.

=LastVisit+IntervalDays
Recipe, demo & practice file →

A base service fee plus a per-linear-foot rate around the building's perimeter.

=Base+Perimeter*PerFoot
Recipe, demo & practice file →

Solar

Estimate yearly dollar savings from annual production and the utility rate.

=AnnualkWh*Rate
Recipe, demo & practice file →

Divide monthly production by usage to see how much of the bill solar covers.

=Produced/Used
Recipe, demo & practice file →

Divide array DC watts by inverter AC watts to check the system is sized in the healthy range.

=ROUND(DC/AC,2)
Recipe, demo & practice file →

System size times sun hours, days, and a derate factor — monthly kWh.

=kW*SunHours*30*Derate
Recipe, demo & practice file →

Convert a kilowatt system size into the number of panels to install.

=ROUNDUP(SystemKW*1000/PanelWatts,0)
Recipe, demo & practice file →

Divide the net system cost by annual savings to get simple payback.

=NetCost/AnnualSavings
Recipe, demo & practice file →

Towing & Recovery

AVERAGEIF the call log to see each driver's average minutes to scene.

=AVERAGEIF(Drivers,Name,Minutes)
Recipe, demo & practice file →

Include a free-mileage radius, then bill only the miles beyond it.

=Hookup+MAX(0,Miles-Free)*PerMile
Recipe, demo & practice file →

Quote a tow as a flat hookup fee plus a per-mile charge.

=Hookup+Miles*PerMile
Recipe, demo & practice file →

Bill at least one day of storage, then a daily rate after that.

=MAX(1,Days)*DailyRate
Recipe, demo & practice file →

Car Wash & Detailing

See your average ticket when a share of customers take an upsell.

=Base+TakeRate*Upsell
Recipe, demo & practice file →

Cost each chemical per car from ounces used, then SUM the stack.

=SUM(CostPerCarRange)
Recipe, demo & practice file →

Look up a detail package name and return its price from a rate table.

=VLOOKUP(Package,Table,2,FALSE)
Recipe, demo & practice file →

Find how many washes a month make an unlimited membership pay off.

=ROUNDUP(MonthlyPrice/SingleWash,0)
Recipe, demo & practice file →

Pressure Washing

Quote by the square foot but never below a job minimum.

=MAX(Minimum,SqFt*Rate)
Recipe, demo & practice file →

Estimate on-site hours from the area and your production rate.

=Area/RatePerHour
Recipe, demo & practice file →

Total the individual surface prices, then apply a bundle discount in the same formula.

=SUM(Surfaces)*(1-Discount)
Recipe, demo & practice file →

Multiply your machine's GPM by minutes run to estimate gallons used.

=GPM*Hours*60
Recipe, demo & practice file →

Locksmith

Apply a 1.5x labor multiplier to night and weekend calls with IF.

=Trip+Hours*Rate*IF(AH="Yes",1.5,1)
Recipe, demo & practice file →

Multiply keys cut by price per key to track counter revenue.

=Keys*PricePerKey
Recipe, demo & practice file →

One trip fee plus a per-lock rekey rate across the whole job.

=Trip+Locks*PerLock
Recipe, demo & practice file →

Quote a job as a trip fee plus labor hours times your rate.

=TripFee+Hours*Rate
Recipe, demo & practice file →

Add dispatch, drive, and on-site minutes to see the wait the customer actually experiences.

=SUM(Dispatch,Drive,OnSite)
Recipe, demo & practice file →

Roofing

Break a total roof bid down to the price per square.

=TotalBid/Squares
Recipe, demo & practice file →

Turn roof squares into shingle bundles, waste included, rounded up.

=ROUNDUP(Squares*3*(1+Waste),0)
Recipe, demo & practice file →

Convert roof squares into rolls of underlayment, rounded up.

=ROUNDUP(Squares*100/RollSqFt,0)
Recipe, demo & practice file →

Junk Removal

Convert scale-ticket pounds to tons and multiply by the landfill rate.

=Pounds/2000*PerTon
Recipe, demo & practice file →

Charge only the pounds over the included allowance, never a negative amount.

=MAX(0,Weight-Allow)*Rate
Recipe, demo & practice file →

Charge a fraction of the full-truck price, floored at a single-item minimum.

=MAX(Minimum,FullLoad*Fraction)
Recipe, demo & practice file →

Show how full the truck is as a percent of its capacity.

=Load/Capacity
Recipe, demo & practice file →

Price a haul by the fraction of the truck it fills.

=ROUND(LoadFraction*FullLoadPrice,0)
Recipe, demo & practice file →

Vending

Divide units on hand by daily sales, rounded down, to time restocks.

=ROUNDDOWN(OnHand/PerDay,0)
Recipe, demo & practice file →

Subtract cost from price and divide by price to get each item's margin.

=(Price-Cost)/Price
Recipe, demo & practice file →

Multiply gross sales by the agreed rate to find what the host location is owed.

=PRODUCT(Gross,Rate)
Recipe, demo & practice file →

Multiply unit margin by daily sales to see a machine's daily profit.

=(Price-Cost)*UnitsPerDay
Recipe, demo & practice file →

Compute how many to refill from par level minus current stock.

=MAX(Par-Current,0)
Recipe, demo & practice file →

Appliance Repair

Credit the paid diagnostic fee against the repair to get the balance due.

=TotalRepair-DiagnosticPaid
Recipe, demo & practice file →

Pull a flat repair price from a book-rate table with VLOOKUP.

=VLOOKUP(Job,RateTable,2,FALSE)
Recipe, demo & practice file →

Bill a diagnostic fee plus labor rounded up to whole half-hour blocks.

=Diag+ROUNDUP(Min/30,0)*BlockRate
Recipe, demo & practice file →

Recommend replace when repair tops half the replacement AND the unit is past half its lifespan.

=IF(AND(Repair>0.5*Replace,Age>0.5*Life),"Replace","Repair")
Recipe, demo & practice file →

Compare age in months against warranty length so the tech knows who pays before the truck rolls.

=IF(Age>Term,"Out of warranty","Covered")
Recipe, demo & practice file →

Window Cleaning

Quote interior and exterior panes at separate per-pane rates.

=IntPanes*IntRate+ExtPanes*ExtRate
Recipe, demo & practice file →

Divide panes cleaned by hours worked to get the production rate you bid future jobs from.

=ROUND(Panes/Hours,1)
Recipe, demo & practice file →

Price the panes and the screens separately, then add the two lines.

=Panes*Rate+Screens*ScreenFee
Recipe, demo & practice file →

Multiply the pane price by a ladder multiplier when the house has upper stories.

=Panes*Rate*IF(Stories>1,1.5,1)
Recipe, demo & practice file →

Tutoring & Test Prep

Charge the full rate when a student attends, a set percent when they no-show.

=IF(Attended,Rate,Rate*Percent)
Recipe, demo & practice file →

Divide a package price by its hours to show the effective hourly rate.

=PackagePrice/Hours
Recipe, demo & practice file →

Subtract the hours used from the package to show each student's balance.

=Package-SUM(UsedRange)
Recipe, demo & practice file →

Dog Walking

Apply a surcharge multiplier to the walk rate only on holidays.

=Rate*IF(Holiday,1+Surcharge,1)
Recipe, demo & practice file →

Turn a weekly walk schedule into a monthly invoice amount.

=ROUND(WalksPerWeek*4.33*Price,2)
Recipe, demo & practice file →

Full rate for the first dog, a discounted rate for each additional dog.

=Rate+(Dogs-1)*Rate*(1-Disc)
Recipe, demo & practice file →

Handyman

Charge the half-day rate up to four hours, the full-day rate beyond.

=IF(Hours<=4,HalfDay,FullDay)
Recipe, demo & practice file →

Add materials to labor hours times your rate for a quick estimate.

=Materials+Hours*Rate
Recipe, demo & practice file →

One trip charge plus the sum of every task on the punch list.

=Trip+SUM(TaskRange)
Recipe, demo & practice file →

Pet Grooming

Bill dematting in 15-minute blocks, rounded up, on top of the base groom.

=Base+ROUNDUP(Min/15,0)*Fee
Recipe, demo & practice file →

FLOOR divides the minutes a groomer is open by the average grooming slot length to show whole appointment slots per day, the base number every booking calendar is built from.

=FLOOR(OpenMinutes/SlotMinutes,1)
Recipe, demo & practice file →

Add the base groom and selected add-ons into one ticket total.

=SUM(Base:AddOns)
Recipe, demo & practice file →

Plumbing

Multiply the run by the slope per foot to find how far a drain line must drop.

=PRODUCT(Run,Slope)
Recipe, demo & practice file →

One trip fee plus the sum of every fixture install on the visit.

=Trip+SUM(FixtureRange)
Recipe, demo & practice file →

Trip fee covers the first hour; bill extra hours and parts on top.

=Trip+MAX(0,Hours-1)*Rate+Parts
Recipe, demo & practice file →

Multiply each fixture's count by its DFU value and SUM to size the drain.

=SUM(Count*DFU per fixture)
Recipe, demo & practice file →

Electrician

Divide the total conductor area by the conduit's inside area and flag anything over 40 percent.

=ROUND(Conductors*WireArea/ConduitArea,4)
Recipe, demo & practice file →

Add the circuit loads and divide by the panel rating to see how full a panel is.

=SUM(Loads)/Rating
Recipe, demo & practice file →

Work out the voltage lost over a wire run and express it as a percent of supply voltage.

=ROUND(2*L*I*R/1000/V,4)
Recipe, demo & practice file →

Price a run as feet of wire times cost per foot, plus labor hours.

=Feet*CostPerFt+Hours*Rate
Recipe, demo & practice file →

Tree Service

Divide the crew's day rate by trees handled to get the cost per tree.

=QUOTIENT(DayRate,Trees)
Recipe, demo & practice file →

Round chip volume up to whole truckloads, then multiply by the dump fee.

=ROUNDUP(Yards/Cap,0)
Recipe, demo & practice file →

Multiply the stack dimensions for cubic feet, then divide by 128 to get cords.

=Length*Height*Depth/128
Recipe, demo & practice file →

Price per inch of stump diameter, but never below your minimum.

=MAX(Minimum,Inches*PerInch)
Recipe, demo & practice file →

Laundromat

Turn wash loads per hour and dry time into the number of dryers needed to keep up.

=ROUNDUP(LoadsPerHour*DryMin/60,0)
Recipe, demo & practice file →

Divide cycles run by machine count — the utilization number laundromats live on.

=Cycles/Machines
Recipe, demo & practice file →

Add water, electricity, and gas cost into the true utility cost behind one wash.

=SUM(Water,Power,Gas)
Recipe, demo & practice file →

Price a wash-dry-fold order by the pound, floored at an order minimum.

=MAX(Minimum,Pounds*Rate)
Recipe, demo & practice file →

Sign Shop

Convert inches to square feet, price per square foot, floor at a minimum.

=MAX(Min,W*H/144*Rate)
Recipe, demo & practice file →

Compare the area you actually used against the full sheet to see how much material went in the bin.

=(Sheet-Used)/Sheet
Recipe, demo & practice file →

A flat setup fee plus a per-character rate for cut vinyl lettering.

=Setup+Characters*PerChar
Recipe, demo & practice file →

Multiply quantity by length, add a waste factor, and round up to whole feet of vinyl.

=ROUNDUP(Qty*Length*(1+Waste),0)
Recipe, demo & practice file →

Chimney Sweep

Turn a measured deposit thickness into an industry Level 1, 2, or 3 rating with nested IFs.

=IF(T<0.125,"Level 1",IF(T<0.25,"Level 2","Level 3"))
Recipe, demo & practice file →

A base sweep for the first flue, a lower rate for each additional flue.

=Base+(Flues-1)*Additional
Recipe, demo & practice file →

Gutter Cleaning

Round gutter footage up to whole debris bags so the truck leaves with enough.

=ROUNDUP(Feet/PerBag,0)
Recipe, demo & practice file →

Price gutters by the linear foot, floored at a service minimum.

=MAX(Minimum,LinearFt*Rate)
Recipe, demo & practice file →

Fencing

Divide the section width by the picket face plus its gap, and round up to whole pickets.

=ROUNDUP(Width/(Face+Gap),0)
Recipe, demo & practice file →

Divide the fence run by the panel width, round up for panels, and add one for the posts.

=ROUNDUP(Run/Panel,0)
Recipe, demo & practice file →

Carpet Cleaning

Divide the wet area by each air mover's coverage and round up to whole units.

=ROUNDUP(SqFt/PerMover,0)
Recipe, demo & practice file →

Price rooms at a flat per-room rate, then take the larger of that total and your service minimum.

=MAX(Rooms*Rate,Minimum)
Recipe, demo & practice file →

FLOOR divides available minutes per day by job time plus drive time between stops to find jobs per day, then multiplies by days worked for a weekly capacity number.

=FLOOR(AvailMin/(JobMin+DriveMin),1)*Days
Recipe, demo & practice file →

Courier & Delivery

Add a route base, a per-stop rate, and a per-mile rate into one driver settlement figure.

=Base+Stops*Rate+Miles*Mile
Recipe, demo & practice file →

Charge only for attempts past the first by clamping the count at zero with MAX, then multiply by your redelivery rate.

=MAX(0,Attempts-1)*FeePerAttempt
Recipe, demo & practice file →

Equipment Rental

Charge the daily rate or the weekly rate, whichever is cheaper for the customer.

=MIN(Days*Day,Week)
Recipe, demo & practice file →

Release the deposit only when every return condition is met, using AND inside IF.

=IF(AND(A,B,C),"Release","Hold")
Recipe, demo & practice file →

Charge only the days a rental runs past its allowed period, never a negative, using MAX.

=MAX(0,DaysOut-Allowed)*DayRate
Recipe, demo & practice file →

Flooring

Divide room width by plank width to get the row count, then check how thin the last row lands.

=ROUNDUP(Width/Plank,0)
Recipe, demo & practice file →

Divide the floor area by the coverage of one roll and round up to whole rolls.

=ROUNDUP(SqFt/RollCoverage,0)
Recipe, demo & practice file →

Painting

Trim is not part of the wall — it is a separate, slower line of work, and painters price it by the linear foot. Measure the run of baseboard, crown, or casing, multiply by a per-foot rate, and keep it off the wall-area bid.

Turn room dimensions into paintable wall area by subtracting doors and windows from the perimeter run.

=2*(L+W)*H-Openings
Recipe, demo & practice file →

Price baseboard, crown, and casing by the linear foot times a per-foot rate, kept separate from the wall area.

=LinearFeet*Rate
Recipe, demo & practice file →

Septic Service

Septic sizing starts with how much water a household sends to the tank each day. Multiply the number of people by a gallons-per-person-per-day figure and you have the design flow that drives tank and field sizing.

Estimate a home's daily wastewater flow from the number of occupants times gallons per person per day.

=People*GallonsPerPerson
Recipe, demo & practice file →

Look up the recommended years between septic pump-outs from the number of people on the tank.

=VLOOKUP(People,Table,2,FALSE)
Recipe, demo & practice file →

Garage Door

A torsion spring is rated for a set number of open-close cycles, not a set number of years. Divide the rating by how many cycles the door runs a day, then by 365, and you get the expected life in years for that household.

Subtract the cycles already used from the spring's rating, then convert what is left into years.

=(Rated-Used)/(PerDay*365)
Recipe, demo & practice file →

Turn a torsion spring's rated cycles into years of life from how many times the door runs each day.

=ROUND(Rating/(PerDay*365),1)
Recipe, demo & practice file →

Auto Glass

A small chip fills; a long crack does not. The industry rule of thumb is that damage up to about six inches is repairable and anything longer needs a new windshield. One IF turns the measured length into that verdict.

Add the calibration fee to the glass price only when the vehicle needs it, using IF.

=IF(Cal="Yes",Glass+Fee,Glass)
Recipe, demo & practice file →

Flag a windshield chip as a repair or a full replacement from the length of the damage.

=IF(Length<=6,"Repair","Replace")
Recipe, demo & practice file →

Welding & Fabrication

A welder's duty cycle is the share of a ten-minute block it can run at a given amperage before it needs to cool. Turn that percentage into minutes and you know how long you can weld before the machine forces a break.

Turn a welder's duty-cycle percentage into how many minutes you can weld before it must cool.

=DutyPct/100*10
Recipe, demo & practice file →

Divide total weld length by the inches one rod deposits, round up, and price the box.

=ROUNDUP(WeldIn/InchesPerRod,0)
Recipe, demo & practice file →

Mobile Notary

Many states cap the per-stamp notary fee, so mobile notaries bundle a base fee that includes the first notarization and charge a set amount for each extra one. MAX keeps the extra count from ever going negative.

Charge a base fee that includes one stamp, then a per-stamp fee for every notarization beyond it.

=Base+MAX(0,Stamps-Included)*PerStamp
Recipe, demo & practice file →

Add the signing base to mileage, but never charge less than a travel minimum, using MAX inside a sum.

=Base+MAX(Miles*Rate,TravelMin)
Recipe, demo & practice file →

ROUNDUP divides a monthly revenue goal by the average fee per signing to show exactly how many signings to book, rounded up because a partial signing does not pay a partial fee.

=ROUNDUP(Goal/AvgFee,0)
Recipe, demo & practice file →

Blinds & Shades

When you need to price a restring or match replacement slats, you first need the count. Divide the window height by the slat spacing and round down, and you have how many slats stack up the blind.

Subtract the factory deduction from the opening and round to the nearest eighth for the order width.

=ROUNDDOWN((Opening-Deduct)*8,0)/8
Recipe, demo & practice file →

Estimate how many slats a blind has from the window height and the slat spacing.

=ROUNDDOWN(Height/Spacing,0)
Recipe, demo & practice file →

Upholstery

Patterned fabric has to line up across cushions and panels, and matching a repeat means cutting around waste. Take your plain-fabric yardage, pad it by a waste percentage for the repeat, and round up to whole yards.

Total the fabric inches across all cushions, divide by 36, and round up to whole yards.

=ROUNDUP(Cushions*InchEach/36,0)
Recipe, demo & practice file →

Pad plain-fabric yardage for the waste of matching a repeating pattern, then round up to whole yards.

=ROUNDUP(BaseYards*(1+Waste%),0)
Recipe, demo & practice file →

Masonry

A block wall goes up in courses, and each standard CMU with its mortar joint adds eight inches of height. Divide the wall height by the course height and you know how many rows the wall stands.

Divide the wall height by the course height to get how many rows of block a wall stands.

=ROUNDDOWN(WallHeight/CourseHeight,0)
Recipe, demo & practice file →

Divide the block count by the blocks one bag of mortar sets, and round up to whole bags.

=ROUNDUP(Blocks/BlocksPerBag,0)
Recipe, demo & practice file →

Powder Coating

Powder is bought by the pound, and the amount a job burns tracks its surface area. Multiply the square feet to coat by a pounds-per-square-foot usage rate — padded for overspray — and you know how much powder to shoot.

Price parts by surface area, but never below the shop minimum, using MAX.

=MAX(Area*Rate,Minimum)
Recipe, demo & practice file →

Estimate the pounds of powder a job needs from the part's surface area times a usage rate per square foot.

=Area*UsageRate
Recipe, demo & practice file →

Holiday Lighting

Christmas lights come in fixed-length strands, and a roofline runs however long it runs. Divide the roofline by the strand length and round up, and you know how many strands to bring so you never come up a gable short.

Count bulbs from run length and spacing, then check the amp draw against the circuit with IF.

=ROUNDUP(Feet*12/Spacing,0)
Recipe, demo & practice file →

Divide the roofline length by the length of one light strand and round up to the strands to buy.

=ROUNDUP(Roofline/StrandLength,0)
Recipe, demo & practice file →

Boat Detailing

Marine detailers price by the foot because a 30-footer is roughly a third more hull than a 22-footer. Multiply the length by your per-foot rate, add the extras a customer opts into, and the quote writes itself.

Estimate how many labor hours a detail job will take from the boat's length and your minutes-per-foot pace.

=ROUND(Length*MinPerFoot/60,1)
Recipe, demo & practice file →

Quote a detail job from the boat's length times a per-foot rate, then add the extras like oxidation removal or ceramic coating.

=Length*Rate+AddOns
Recipe, demo & practice file →

Window Tint

Tint film is bought by the square foot off a roll, but every pane you cut leaves a trimmed edge. Convert the pane size to square feet, multiply by how many like it there are, and pad it for waste so you never come up a strip short.

ROUNDUP divides the number of cars waiting for tint by how many a crew can finish in a day, converting a backlog count into a scheduling number: whole crew-days needed to clear it.

=ROUNDUP(Backlog/CarsPerCrewDay,0)
Recipe, demo & practice file →

Turn pane width, height, and count into the square feet of film to buy, with a waste factor for trimming.

=ROUNDUP(W*H*Qty/144*1.15,0)
Recipe, demo & practice file →

Multiply the film's VLT by the glass's own VLT to get the true net light transmission a customer will actually see through.

=ROUND(FilmVLT*GlassVLT/100,1)
Recipe, demo & practice file →

Tailoring & Alterations

A tailor's prices live on a printed menu: hem pants, take in a waist, replace a zipper. Put that menu in the sheet once and VLOOKUP prices every ticket the same way, so nobody has to remember what a zipper costs this month.

Read each alteration's price straight off your service menu with an exact-match VLOOKUP.

=VLOOKUP(Service,Menu,2,FALSE)
Recipe, demo & practice file →

Add up the alteration line items, then hold the ticket to a shop minimum so a single tiny fix still covers your time.

=MAX(SUM(items),Minimum)
Recipe, demo & practice file →

Screen Printing

Screen printing has two costs baked in: burning a screen for each ink color, and printing each shirt. Charge one screen fee per color and a per-shirt price times the run, and both the one-color job and the four-color job land at a fair number.

Turn shirt count, color count, and per-hit coverage into the ounces of ink to mix, rounded up so you never run dry mid-run.

=ROUNDUP(Shirts*Colors*OzPerHit,0)
Recipe, demo & practice file →

Price a print run as one screen fee per ink color plus a per-shirt charge times the quantity.

=Colors*ScreenFee+Qty*Unit
Recipe, demo & practice file →

IFS looks up the correct per-shirt price for an order's quantity tier and multiplies by the quantity, so a 150-shirt order automatically prices lower per unit than an 18-shirt order.

=Qty*IFS(Qty<25,12,Qty<50,9.5,Qty<100,7.5,TRUE,6)
Recipe, demo & practice file →

Bounce House Rental

A bounce house has a rider limit, and a birthday party has a guest list. Divide the kids by the per-unit capacity and round up, and you know whether one inflatable covers the party or you need to send two.

Divide the number of kids by how many a bounce house safely holds, then round up to the units to book.

=ROUNDUP(Kids/Capacity,0)
Recipe, demo & practice file →

Charge a flat base for the included block, then bill only the hours beyond it at an hourly rate.

=Base+MAX(0,Hours-Included)*Hourly
Recipe, demo & practice file →

Knife Sharpening

Serrated edges take longer than a straight blade, so they cost more to sharpen. Count the plain blades at your base rate, the serrated ones at the base plus a surcharge, and the ticket totals itself.

Price a sharpening ticket as plain blades at the base rate plus serrated blades at a surcharge.

=Plain*Rate+Serrated*(Rate+Surcharge)
Recipe, demo & practice file →

Look up a per-knife rate that drops as the count rises, then multiply by how many knives are on the ticket.

=Knives*VLOOKUP(Knives,tiers,2,TRUE)
Recipe, demo & practice file →

Portable Toilet Rental

One portable toilet comfortably serves about 50 guests for a four-hour event — that is 200 guest-hours per unit. Multiply guests by hours, divide by 200, and round up to the units the event needs.

Size an event's portable toilets from the guest count and how many hours it runs.

=ROUNDUP(Guests*Hours/200,0)
Recipe, demo & practice file →

Bill a long-term rental by units times weeks of service times the per-service rate, plus a flat delivery fee.

=Units*Weeks*Rate+Delivery
Recipe, demo & practice file →

Escape Room

An escape room slot costs the same to run whether two people book it or eight. A minimum party size protects that slot: charge the greater of the actual players or the minimum, times the per-player price.

Charge the greater of the actual players or a minimum party size, times the per-player price.

=MAX(Players,MinPlayers)*Price
Recipe, demo & practice file →

Divide the number of rooms running at once by how many a single game master can watch, rounded up to whole staff.

=ROUNDUP(Rooms/RoomsPerGM,0)
Recipe, demo & practice file →

FLOOR divides the minutes a room is open by the session length plus the reset time between groups, rounding down because a partial slot cannot be sold.

=FLOOR((Close-Open)*24*60/(Session+Reset),1)
Recipe, demo & practice file →

Embroidery

Embroidery is priced by stitches, not by ink. Charge a one-time digitizing fee to turn the artwork into a stitch file, then price each piece by its stitch count — usually a rate per thousand stitches.

Divide a design's stitch count by the machine's stitches-per-minute to estimate how long each piece will run.

=ROUND(Stitches/SPM,1)
Recipe, demo & practice file →

Price an embroidery order as a one-time digitizing setup plus a per-piece run based on stitch count.

=Setup+Qty*(Stitches/1000*Rate)
Recipe, demo & practice file →

Photo Booth Rental

CEILING rounds overtime minutes up to the next 15-minute billing increment before converting to hours and applying the overtime rate, so a 4-minute overrun and a 14-minute overrun both bill the same block.

=CEILING(MAX(0,Actual-Package),15)/60*Rate
Recipe, demo & practice file →

Look up a fixed package price from the number of hours booked with an exact-match VLOOKUP.

=VLOOKUP(Hours,packages,2,FALSE)
Recipe, demo & practice file →

Turn expected sessions and prints-per-session into whole media packs so you never run out of paper mid-reception.

=ROUNDUP(Sessions*PrintsEach/PackPrints,0)
Recipe, demo & practice file →

DJ Services

Bill hours times your rate, but never below a minimum gig charge that covers load-in, setup, and teardown.

=MAX(Hours*Rate,Minimum)
Recipe, demo & practice file →

Divide the set length by your average track length to know how many songs to prep for each block of the night.

=ROUNDUP(Hours*60/AvgTrackMin,0)
Recipe, demo & practice file →

Mobile Bartending

Size the ice order from guest count plus the chilling ice that never ends up in a glass, then round up to whole bags.

=ROUNDUP((Guests*LbPerGuest+ChillLb)/BagLb,0)
Recipe, demo & practice file →

Divide the guest count by how many guests one bartender can serve, rounded up to whole staff.

=ROUNDUP(Guests/PerBartender,0)
Recipe, demo & practice file →

Balloon Decor

Multiply the garland length by balloons-per-foot and round up to know how many to inflate.

=ROUNDUP(Feet*PerFoot,0)
Recipe, demo & practice file →

Multiply balloon count by the cubic feet each size takes, divide by tank capacity, and round up to whole tanks.

=ROUNDUP(Balloons*CuFtEach/TankCuFt,0)
Recipe, demo & practice file →

Axe Throwing

Multiply lanes by hours by the per-lane hourly rate to price a session or forecast a busy night.

=Lanes*Hours*Rate
Recipe, demo & practice file →

Booked lane-hours divided by total lane-hours available for the week shows the share of your throwing lanes that were actually earning, the same utilization math used for any bookable-capacity business.

=BookedHours/AvailableHours
Recipe, demo & practice file →

Convert monthly throw volume into whole replacement boards so lumber gets ordered before a target falls apart.

=ROUNDUP(Sessions*Throwers*ThrowsEach/BoardLife,0)
Recipe, demo & practice file →

Mini Golf

Add up a mixed group's admission by multiplying each ticket type by its price and summing.

=Adults*A+Kids*K+Seniors*S
Recipe, demo & practice file →

Multiply rounds by the win rate and the prize value to price what a hole-in-one promotion actually costs each month.

=ROUND(Rounds*WinRate*PrizeValue,2)
Recipe, demo & practice file →

Snow Cone & Shaved Ice

Turn expected servings and cup size into whole blocks of ice, so the shaver never stops on a hot Saturday.

=ROUNDUP(Servings*OzEach/(BlockLb*16),0)
Recipe, demo & practice file →

Divide a gallon's ounces by the ounces of syrup per cone and round down to whole servings.

=ROUNDDOWN(BottleOz/OzPerCone,0)
Recipe, demo & practice file →

Face Painting

Multiply artists by hours by faces-per-hour to see how many faces an event can actually get through.

=Artists*Hours*FacesPerHour
Recipe, demo & practice file →

Add up the paints, sponges, glitter and wipes an event burns, divide by faces painted, and see the true consumable cost.

=ROUND(SUM(B2:E2)/F2,2)
Recipe, demo & practice file →

Pet Waste Removal

Multiply the visits per month by the per-visit rate and add a flat monthly base fee.

=Visits*Rate+Base
Recipe, demo & practice file →

Divide the working day by service time plus drive time to see how many yards one tech can honestly cover.

=ROUNDDOWN(WorkMin/(ServiceMin+DriveMin),0)
Recipe, demo & practice file →

Spray Tanning

Strip solution, disposables, card fees and room cost out of the price to see what a single session really leaves behind.

=ROUND(Price-Solution-Disposables-Price*CardPct-Room,2)
Recipe, demo & practice file →

Multiply sessions by millilitres per session, divide by the bottle size, and round up to whole bottles.

=ROUNDUP(Sessions*MlPerSession/BottleMl,0)
Recipe, demo & practice file →

Valet Parking

Divide usable lane length by the feet a stacked car occupies, round down, and multiply by the number of lanes.

=ROUNDDOWN(LaneFt/FtPerCar,0)*Lanes
Recipe, demo & practice file →

Price a valet event as attendants times hours times the hourly rate, plus a flat setup fee.

=Attendants*Hours*Rate+Setup
Recipe, demo & practice file →

Tent & Canopy Rental

Turn required hold-down weight per leg into whole concrete blocks so a parking-lot tent is anchored to spec, not to guesswork.

=ROUNDUP(Legs*LbsPerLeg/BlockLbs,0)
Recipe, demo & practice file →

Turn guests and square feet per guest into a tent size rounded up to the next whole 20-foot section you actually stock.

=ROUNDUP(Guests*SqFtEach/Module,0)*Module
Recipe, demo & practice file →

Limo & Party Bus

Round total garage-to-garage minutes up to the next half hour, then apply the contract minimum with MAX.

=MAX(MinHours,ROUNDUP(Minutes/30,0)/2)
Recipe, demo & practice file →

Round guests up into whole bus trips, then multiply by the round-trip loop time so you know when to start the shuttle.

=ROUNDUP(Guests/Capacity,0)*(2*DriveMin+LoadMin)
Recipe, demo & practice file →

Paintball Field

Subtract the reserve you will never use, then divide the usable air by what one player fill takes to see how many fills a bottle really gives.

=ROUNDDOWN(BottleCuFt*(1-Reserve)/FillCuFt,0)
Recipe, demo & practice file →

Multiply players by pods and pod size, divide by the balls in a case, and round up to whole cases.

=ROUNDUP(Players*Pods*BallsPerPod/BallsPerCase,0)
Recipe, demo & practice file →

Rock Climbing Gym

Subtract logged hours from the manufacturer's rated hours and divide by monthly use to see how long a gym rope has left.

=ROUNDDOWN((Rated-Logged)/PerMonth,0)
Recipe, demo & practice file →

Multiply routes by hours per route, divide by a setter's productive day, and round up to whole setter-days.

=ROUNDUP(Routes*HrsPerRoute/SetterDayHrs,0)
Recipe, demo & practice file →

Florist

Build a per-piece minute cost from stem count and prep, then divide an hour by it to get honest bench capacity.

=ROUNDDOWN(60/(Stems*MinPerStem+Prep),0)
Recipe, demo & practice file →

Scale stems per arrangement by the wholesale count, add a shrink allowance, and round up to whole bunches.

=ROUNDUP(Arrangements*StemsEach*(1+Shrink)/StemsPerBunch,0)
Recipe, demo & practice file →

Bike Shop

Divide the service queue by daily wrench capacity and round up to give customers an honest pickup day.

=ROUNDUP(Queue/(Techs*JobsPerDay),0)
Recipe, demo & practice file →

Divide chainring teeth by cog teeth and multiply by wheel diameter to compare any two gearing setups on one scale.

=ROUND(Chainring/Cog*WheelDia,1)
Recipe, demo & practice file →

Trampoline Park

Take the lower of the space limit and the supervision limit with MIN, so a session is capped by whichever binds first.

=MIN(ROUNDDOWN(CourtSqFt/SqFtEach,0),Monitors*PerMonitor)
Recipe, demo & practice file →

Divide open minutes by jump time plus changeover so the timetable counts the emptying and briefing, not just the jumping.

=ROUNDDOWN(OpenMin/(JumpMin+Changeover),0)
Recipe, demo & practice file →

Butcher Shop

Divide saleable weight by hanging weight for a yield percentage, then divide cost by saleable pounds for the real cost per pound.

=ROUND(SaleableLb/HangingLb,3) and =ROUND(Cost/SaleableLb,2)
Recipe, demo & practice file →

Solve for the pounds of pure fat that move a lean trim to a target fat percentage, instead of guessing at the grinder.

=ROUND(Lean*(Target-Current)/(1-Target),1)
Recipe, demo & practice file →

Bowling Alley

Handicap, lane and league math for a bowling centre.

Take the gap between the league basis and a bowler's average, apply the handicap percentage, and floor it — with no negative handicaps.

=ROUNDDOWN(MAX(Basis-Average,0)*Pct,0)
Recipe, demo & practice file →

Subtract lineage and the secretary's cut from the weekly fee so the prize fund is a number you can defend at the banquet.

=Fee-Games*Lineage-Secretary
Recipe, demo & practice file →

Laser Tag

Fleet sizing, session and arena math for laser tag operators.

Turn a day's play minutes into whole charge cycles with ROUNDUP so you know how many mid-day battery swaps the crew has to schedule.

=ROUNDUP(Games*GameMin/RuntimeMin,0)-1
Recipe, demo & practice file →

Multiply players per game by arenas running, add a spare share for charging and repair, and round up to whole packs.

=ROUNDUP(Players*Arenas*(1+Spare),0)
Recipe, demo & practice file →

Go-Kart Track

Lap counts, session formats and track throughput for karting.

Convert kart-minutes into engine-hours, then multiply by burn rate to size the fuel order for a full race day.

=ROUND(Karts*Sessions*Min/60*GPH,2)
Recipe, demo & practice file →

Convert session minutes to seconds and divide by the average lap time to advertise a lap count you can actually deliver.

=ROUNDDOWN(Minutes*60/LapSeconds,0)
Recipe, demo & practice file →

Batting Cages

Tokens, pitches and practice planning for cage facilities.

Convert miles per hour into feet per second, then divide by distance to show a hitter exactly how long a cage pitch really gives them.

=ROUND(Distance/(MPH*5280/3600),3)
Recipe, demo & practice file →

Turn players and swings each into whole tokens using the pitch count one token buys, so a coach pre-buys the right card.

=ROUNDUP(Players*Swings/PitchesPerToken,0)
Recipe, demo & practice file →

Kayak & Canoe Rental

Float times, shuttles and livery planning for paddle-sport outfitters.

Apply a 75% working limit to the rated capacity, subtract paddlers and gear, and let IF call the boat over or clear.

=ROUND(Rated*0.75,0)-(Paddlers+Gear)
Recipe, demo & practice file →

Add paddling speed to river current and divide the run's distance by it to give paddlers an honest shuttle-back time.

=ROUND(Miles/(PaddleMph+CurrentMph),1)
Recipe, demo & practice file →

Charter Fishing

Limits, headcounts and trip math for for-hire fishing vessels.

Take the lower of the per-angler limit times the headcount and the vessel limit, so the mate calls the count correctly.

=MIN(Anglers*PerAngler,BoatLimit)
Recipe, demo & practice file →

Subtract the round-trip run from the charter length so the trip you advertise and the trip customers get are the same trip.

=MAX(0,Hours-2*(Miles/Knots))
Recipe, demo & practice file →

Campground & RV Park

Metered utilities, site billing and occupancy math for parks and campgrounds.

Discount the tank to a usable volume, divide by daily use, and round down so the dump station visit is scheduled rather than discovered.

=ROUNDDOWN(Tank*Usable/(People*GalPerDay),0)
Recipe, demo & practice file →

Subtract meter reads, price the kilowatt-hours, and add the flat service fee to bill a long-term site accurately.

=ROUND((EndRead-StartRead)*Rate,2)+Fee
Recipe, demo & practice file →

Dance Studio

Recital run times, class capacity and studio scheduling math.

One SUMPRODUCT multiplies each entry type by its own fee, so a dancer's competition invoice is a formula instead of a stack of sticky notes.

=SUMPRODUCT($B$2:$E$2,B3:E3)
Recipe, demo & practice file →

Add the transition to every routine before multiplying, then add intermission, so the show length is the one an audience experiences.

=Routines*(AvgMin+TransitionMin)+Intermission
Recipe, demo & practice file →

Martial Arts Dojo

Rank eligibility, attendance and program math for martial arts schools.

Require both the class count and the time-in-grade with AND, so a student only shows Eligible when every rule is satisfied.

=IF(AND(Classes>=Req,Months>=MinMonths),"Eligible","Not yet")
Recipe, demo & practice file →

LOG base 2 rounded up gives the number of rounds; the next power of two minus the entrants gives the byes.

=ROUNDUP(LOG(Entrants,2),0)
Recipe, demo & practice file →

Music Lessons

Level billing, lesson counts and studio policy math for music teachers.

Subtract studio closure weeks before multiplying, so a term invoice matches the lessons that will actually be taught.

=(Weeks-Closed)*PerWeek*Rate
Recipe, demo & practice file →

Spread a year of lessons evenly across twelve months so families pay the same amount in a five-lesson month and a two-lesson one.

=ROUND(LessonsPerYear*Rate/12,2)
Recipe, demo & practice file →

Swim School

Level progression, lesson planning and capacity math for swim schools.

Divide enrolled by capacity for a fill rate, then price the empty seats so the cost of a half-full class is a dollar figure.

=(Capacity-Enrolled)*Tuition
Recipe, demo & practice file →

Divide the skills still outstanding by the skills mastered per lesson and the lessons per week to give parents a real timeline.

=ROUNDUP(SkillsLeft/SkillsPerLesson/LessonsPerWeek,0)
Recipe, demo & practice file →

Christmas Tree Farm

Planting, survival and rotation math for choose-and-cut tree farms.

Divide the annual harvest target by trees per acre to get the yearly planting block, then multiply by rotation length for the acreage in production.

=Target/PerAcre then x Rotation
Recipe, demo & practice file →

Divide the harvest target by the survival share — not multiply by the loss rate — to order the right number of seedlings.

=ROUNDUP(Target/(1-LossRate),0)
Recipe, demo & practice file →

Winery & Vineyard

Turn harvest tons into finished 750 ml bottles by way of gallons per ton, then ROUNDDOWN because a partial bottle is not a bottle you can sell.

=ROUNDDOWN(Tons*GalPerTon*3.78541/0.75,0)
Recipe, demo & practice file →

Multiply barrels by volume by the annual evaporation rate to size the topping wine you have to hold back all year.

=ROUND(Barrels*GalPerBarrel*EvapRate,2)
Recipe, demo & practice file →

Marina & Boat Slip

Add the fender clearance to the beam and use CEILING to jump to the next standard slip width the marina actually has on the dock.

=CEILING(Beam+Clearance,Increment)
Recipe, demo & practice file →

Turn slip count and annual turnover into openings per year, then divide the waitlist by it for an honest wait estimate.

=ROUND(Waitlist/(Slips*Turnover),1)
Recipe, demo & practice file →

Pottery Studio

Kilowatts times hours times the electric rate gives the firing cost; divide by the pieces in the load to price a single mug.

=ROUND(kW*Hours*Rate/Pieces,2)
Recipe, demo & practice file →

Add up each ramp segment (degrees to climb divided by degrees per hour) plus the hold to predict when a firing finishes and the kiln can be scheduled again.

=(T1-Start)/Rate1+(Target-T1)/Rate2+HoldMin/60
Recipe, demo & practice file →

Horse Stable & Boarding

Horses times pounds per day times days, divided by bale weight and rounded up with ROUNDUP, so the hay order covers the month instead of running out on the 28th.

=ROUNDUP(Horses*LbsPerDay*Days/BaleLbs,0)
Recipe, demo & practice file →

Turn a shoeing cycle in weeks into visits per year, then multiply by horses and visit cost for a budget that survives contact with the calendar.

=ROUND(52/CycleWeeks*Horses*Cost,2)
Recipe, demo & practice file →

Wedding Venue

Guests times the share who dance at once times square feet per dancer gives the floor area; ROUNDUP against the panel size tells the rental company how many panels to bring.

=ROUNDUP(Guests*DancePct*4.5/PanelSqFt,0)
Recipe, demo & practice file →

MAX with a zero floor turns a food-and-beverage minimum into a line item that appears only when the couple falls short.

=MAX(0,Minimum-(Guests*Plate+Bar))
Recipe, demo & practice file →

Arcade & Family Entertainment

Divide the card price by base plus bonus credits to see what a tier really costs per play, and how deep the discount goes.

=ROUND(Price/(Base*(1+Bonus)),3)
Recipe, demo & practice file →

Tickets paid out times what a ticket costs you in prizes, divided by what the game earned, gives the payout percent that tells you whether a redemption game is tuned right.

=Tickets*CostPerTicket/GameRevenue
Recipe, demo & practice file →

Roller Skating Rink

A flat package covers a set number of skaters; MAX(0, guests minus included) times the per-head rate adds the extras without ever going negative for a small party.

=Base+MAX(0,Guests-Included)*ExtraRate
Recipe, demo & practice file →

Multiply the order total by each size share, round to whole pairs, then fix the rounding drift on one line so the parts add back to the total.

=ROUND(Total*Share,0) fix: =Total-SUM(others)
Recipe, demo & practice file →

Ice Rink

Divide the ice bill by MAX of the actual roster and a contracted minimum, so a thin practice does not blow up the per-skater price.

=ROUND((Rate*Hours+Officials)/MAX(Skaters,Min),2)
Recipe, demo & practice file →

Ice hours times 60 over the flood interval, rounded up, is how many times the resurfacer goes out; times gallons per flood is the hot water the boiler has to supply.

=ROUNDUP(IceHours*60/IntervalMin,0)*GalPerFlood
Recipe, demo & practice file →

Golf Course & Driving Range

Buckets a day times balls per bucket times the share that never comes back is monthly ball loss; ROUNDUP turns it into whole cases to order.

=ROUNDUP(Buckets*Balls*Loss%*Days/BallsPerCase,0)
Recipe, demo & practice file →

Subtract the first tee from the last, convert the Excel time to minutes, divide by the interval and add one to count the tee times a day actually has — then times four for player capacity.

=ROUNDDOWN((LastTee-FirstTee)*1440/Interval,0)+1
Recipe, demo & practice file →

Ski & Snowboard Rental

Rental-days out divided by fleet size times days open is the share of your skis that were actually earning. Under 60% and you own too many; over 90% and you are turning people away.

=RentalDays/(Fleet*DaysOpen)
Recipe, demo & practice file →

First day at the full rate, every additional day at a discount — MAX(Days-1,0) counts the extra days so a one-day rental never gets a negative discount.

=Rate+MAX(Days-1,0)*Rate*(1-Discount)
Recipe, demo & practice file →

Pickleball & Tennis Club

Players waiting divided by the four spots per court, rounded up with CEILING, is how many games you sit out; multiply by game length for minutes on the bench.

=CEILING(Waiting/(Courts*4),1)*GameMin
Recipe, demo & practice file →

COMBIN(players,2) counts every pairing in a round robin; divide by courts and round up to see how many rounds — and how many hours — the event actually takes.

=ROUNDUP(COMBIN(Players,2)/Courts,0)
Recipe, demo & practice file →

Dry Cleaner

Pounds of garments over the machine's rated load, rounded up, is the loads; times cycle minutes over 60 is the machine hours the day needs.

=ROUNDUP(Lbs/Capacity,0)*CycleMin/60
Recipe, demo & practice file →

Multiply every piece count by its price and add them up in one SUMPRODUCT — no helper column, no long chain of plus signs on the ticket.

=SUMPRODUCT(Prices,Quantities)
Recipe, demo & practice file →

Shoe Repair

Divide the repair price by the months it adds and the new-shoe price by its expected life; whichever is lower per month is the better deal, and the comparison sells the repair.

=Repair/MonthsAdded vs =NewPrice/LifeMonths
Recipe, demo & practice file →

WORKDAY adds business days to the drop-off date, skipping weekends and the holidays you list, so the ticket promises a day the shop is actually open.

=WORKDAY(DropOff,Days,Holidays)
Recipe, demo & practice file →

Jewelry & Watch Repair

Bench hours times the shop rate, plus grams of metal at the spot price scaled by karat over 24 and marked up — the two halves of every sizing and shank quote.

=Hours*Rate + Grams*Spot*Karat/24*Markup
Recipe, demo & practice file →

Grams times karat over 24 is pure gold content; times the spot price per gram is the melt value that every scrap buy and every trade-in starts from.

=Grams*Karat/24*SpotPerGram
Recipe, demo & practice file →

Beekeeping & Apiary

Hives times the pounds of stores each needs, minus what the hives weigh in with, floored at zero with MAX — then ROUNDUP to whole 50 lb sugar bags.

=MAX(0,Hives*LbPerHive-Stores)
Recipe, demo & practice file →

Hives times frames pulled times pounds per frame is the crop; divide by the jar size and ROUNDDOWN to see how many full jars go to market and how many jars to buy.

=ROUNDDOWN(Hives*Frames*LbsPerFrame/JarLbs,0)
Recipe, demo & practice file →

Orchard & U-Pick Farm

Bushels per tree times pounds per bushel times the gap between the u-pick price and the wholesale price is the extra revenue each tree earns when customers pick it themselves.

=Bushels*LbsPerBushel*(UPickPrice-Wholesale)
Recipe, demo & practice file →

Gross weight on the scale minus the container's tare is the fruit you actually sell; times price per pound is the checkout total.

=(Gross-Tare)*PricePerLb
Recipe, demo & practice file →

Greenhouse & Plant Nursery

Pots times quarts per pot, divided by the quarts in a bag (cubic feet times 25.71), rounded up with ROUNDUP, is the bags to pull before the potting crew starts.

=ROUNDUP(Pots*QtPerPot/(BagCuFt*25.71),0)
Recipe, demo & practice file →

Divide the plants you need by germination percent and again by transplant survival, then ROUNDUP — the seed count that actually fills the order.

=ROUNDUP(Target/(Germ%*Survival%),0)
Recipe, demo & practice file →

Scuba Dive Shop

Usable PSI over the diver's surface air consumption times the pressure factor at depth (depth over 33 plus 1) gives the minutes a tank lasts — rounded down, because air runs out before the fraction does.

=ROUNDDOWN((TankPSI-ReservePSI)/(SAC*(Depth/33+1)),0)
Recipe, demo & practice file →

Pressure used over minutes is your consumption at depth; divide by the absolute pressure in atmospheres (depth/33 + 1) to get the surface rate you can plan any dive with.

=(Start-End)/Minutes/(Depth/33+1)
Recipe, demo & practice file →

Shooting & Archery Range

Box price divided by rounds in the box is the cost of one trigger pull; times shots fired, plus the lane fee, is what the afternoon really cost.

=Shots*(BoxPrice/RoundsPerBox)+LaneFee
Recipe, demo & practice file →

One minute of angle is 1.047 inches at 100 yards, so MOA times 1.047 times yards over 100 converts a scope adjustment or a group size into inches on the target.

=MOA*1.047*Yards/100
Recipe, demo & practice file →

Drive-In Theater

Acres times 43,560 is square feet; times the share that is actually parking (not screen, ramps, snack bar or lanes) divided by square feet per car, rounded down, is the sellout number.

=ROUNDDOWN(Acres*43560*Usable%/SqFtPerCar,0)
Recipe, demo & practice file →

Cars times (people per car times ticket price, plus concession spend per car) is the show's revenue, and it shows why a drive-in counts cars and heads separately.

=Cars*(PerCar*Ticket+Concession)
Recipe, demo & practice file →

Hotel & Motel

Productive shift minutes divided by minutes per room is the rooms one attendant can turn; rooms to clean over that, ROUNDUP, is the number of attendants to schedule.

=ROUNDUP(Rooms/((ShiftMin-BreakMin)/MinPerRoom),0)
Recipe, demo & practice file →

Divides room count by one minus your no-show rate to get how many reservations to accept, then subtracts the room count to show the cushion in plain reservations.

=ROUNDUP(Rooms/(1-NoShow%),0)
Recipe, demo & practice file →

Yoga Studio

IFS steps a teacher's per-class pay through flat, standard and per-student-bonus tiers based on how many students showed up, so a packed class pays more than a nearly-empty one.

=IFS(Students<8,30,Students<=15,40,TRUE,40+(Students-15)*5)
Recipe, demo & practice file →

Pack price over pack classes is the per-class cost; unlimited price over that, ROUNDUP, is the visit count at which the monthly membership becomes the cheaper choice.

=ROUNDUP(Unlimited/(PackPrice/PackClasses),0)
Recipe, demo & practice file →

Car Rental

Hours between pickup and return, minus the grace hour, over 24, ROUNDUP: the number of rental days the counter bills for a late return.

=ROUNDUP(MAX((Return-Pickup)*24-Grace,0)/24,0)
Recipe, demo & practice file →

CEILING rounds partial hours late up to the next full hour block before applying the hourly late fee, and MIN caps the charge at a full day's rate so a very late return never costs more than a new rental.

=MIN(CEILING(HoursLate,1)*15,DailyRate)
Recipe, demo & practice file →

Massage Therapy

Divides the weekly booth rent by the margin each session leaves after supplies (oil, linens, laundry) to show exactly how many sessions a renting therapist must book before the week turns a profit.

=ROUNDUP(Rent/(Price-Supply),0)
Recipe, demo & practice file →

Minutes open divided by session length plus the room-turnover gap, ROUNDDOWN, is how many clients one therapist can actually see; times the price is the day's ceiling.

=ROUNDDOWN(MinutesOpen/(SessionMin+TurnoverMin),0)
Recipe, demo & practice file →

Farmers Market Vendor

SUMPRODUCT multiplies each category's sales by 1 or 0 depending on whether it is taxable, then by the tax rate, and adds it all up in one formula with no helper column.

=SUMPRODUCT((Taxable="Yes")*Sales*Rate)
Recipe, demo & practice file →

Booth fee divided by the margin on one unit (price minus what it cost you to make), ROUNDUP: everything after that many sales is profit for the morning.

=ROUNDUP(BoothFee/(Price-UnitCost),0)
Recipe, demo & practice file →

Vacation Rental

Nights times rate plus the flat cleaning fee, divided back by nights, is what a guest really pays per night — and why short stays feel expensive.

=(Nights*Rate+CleaningFee)/Nights
Recipe, demo & practice file →

Nights booked divided by the actual number of days in that calendar month (28 to 31) gives an occupancy rate that stays accurate all year, using EOMONTH/DAY instead of a hard-coded 30.

=NightsBooked/DAY(EOMONTH(MonthStart,0))
Recipe, demo & practice file →

More recipes publishing regularly. We’re adding new formula recipes across text, logic, conditional formatting, ranking and percentages. Want one covered next? Tell us what you’re stuck on.

Learn the formulas that matter, in one day

Our hands-on Excel Formulas & Functions class turns these recipes into skills — live in Dallas–Fort Worth, Houston, Austin, Oklahoma City, Denver, or online.

See the Formulas & Functions Class