Visual Builder

The Visual Builder lets you construct common formulas through a structured UI instead of raw syntax — great for teaching, for complex nested logic, and for the functions most people have to look up every time.

Supported formulas

The Visual Builder currently covers nine formulas (including three unified builders that handle both the single-condition and multi-condition variants of their function):

QUERY is a Google Sheets-specific function, so the builder hides it when you’re running inside Excel.

How to use it

1. Open the Visual Builder from the sidebar menu (or, in Google Sheets, pick Open Cell in Visual Builder to preload the active cell).
2. Choose the formula you want to build from the Formula dropdown.
3. Fill in the fields — each has a label explaining what it expects.
4. The Live Preview at the bottom shows the generated formula as you edit.
5. Click Insert to write it to the selected cell, or Save to Snippets to stash it for later.

IF builder

The IF builder uses a visual tree:

• Each node is a condition (e.g. A1 > 100) with a then and else branch.
• Either branch can be a plain value, a cell reference, or another nested IF — add as many levels as your logic needs.
• Combine conditions with AND/OR wrappers.

The builder handles all the parentheses and nesting; you just describe the shape.

IFS builder

The IFS builder is a flatter alternative to nested IFs — ideal when you have several independent conditions and want first match wins semantics:

• Each row is one condition → value pair, numbered in evaluation order.
• Duplicate, delete, or reorder rows from the hover menu on each row.
• Add an optional default row (the TRUE arm) for the “if nothing matches” case — it’s auto-inserted when you parse a formula that already has one.
• Pulling an existing =IFS(...) back into the builder round-trips simple per-row conditions; compound AND(...) / OR(...) conditions are preserved but currently edit as their first leaf only.

Conditional aggregation builders (SUMIF/SUMIFS, COUNTIF/COUNTIFS, AVERAGEIF/AVERAGEIFS)

Each of the three conditional-aggregation builders is a single unified builder that covers both the single-condition (-IF) and multi-condition (-IFS) forms of its function. You don’t pick one or the other — you just add as many conditions as you need. The builder emits the -IFS variant when written to the cell, which round-trips cleanly in both directions.

• SUMIF / SUMIFS — adds up values in a sum range, keeping only rows where every condition matches.
• COUNTIF / COUNTIFS — counts cells where every condition matches (no separate sum range — you’re counting rows, not summing a column).
• AVERAGEIF / AVERAGEIFS — averages values in an average range, keeping only rows where every condition matches.

The shape is the same for all three:

1. Target range (SUMIF/AVERAGEIF only) — the column of numbers to aggregate.
2. One or more conditions, each a pair of:
   • Criterion range — the column the condition looks at.
   • Matches — the value or expression to compare against (e.g. "Widget", ">100", "<>done", or a cell reference).

Use the Add condition button to stack more criteria; the Duplicate and Remove icons on each condition row make it easy to iterate on similar filters. Pulling an existing =SUMIF(...), =SUMIFS(...), =COUNTIF(...), =COUNTIFS(...), =AVERAGEIF(...), or =AVERAGEIFS(...) back into the builder fills in the fields correctly for any of those six variants.

Lookup builders (VLOOKUP, XLOOKUP, INDEX+MATCH)

The three lookup builders walk you through the same conceptual fields, adapted to each function’s quirks:

1. Search value — what you’re looking for.
2. Search range — where to look.
3. Return range — what to return.
4. Match type / mode — exact, approximate, wildcard, etc. (XLOOKUP adds search mode for direction.)

INDEX + MATCH can look to the left of the search column — something VLOOKUP can’t. The builder uses that when you pick it, stitching together the two functions for you.

QUERY builder

For Google Sheets’ QUERY function, the builder gives you a structured interface for the SQL-ish fragments:

• Data range — the source table.
• SELECT — which columns to return.
• WHERE — filter conditions.
• ORDER BY — sort results.
• LIMIT — cap the row count.

Each field is optional and composed into the final QUERY string in the preview.

Cross-sheet cell references

Any field that expects a cell or range — A1, B2:B100, the search and return ranges in a lookup, the criterion ranges in a SUMIFS — can point at another sheet in the same workbook.

• Every cell-reference input has a sheet picker as its left-hand badge. It defaults to This sheet (the active tab) so you never need to touch it for same-sheet refs.
• Pick a different sheet to prepend its name to the ref. Names with spaces, punctuation, or non-ASCII characters are auto-quoted ('Sales 2026'!A1:A100); simple names stay unquoted (Lookups!A1).
• Hidden sheets show up in the dropdown with a small hidden badge so you don’t silently reference a tab your teammates can’t see.
• Pasting a fully-qualified reference (e.g. Sheet2!B3 or 'Q1 Data'!A1:A50) into the input also works — the sheet portion jumps up to the picker automatically.

The picker is hidden when the host doesn’t expose a sheet list, so the input stays a plain text field in that case. On narrow Excel add-in widths the picker collapses to an icon with a tooltip to keep the builder usable at ≤300px.

Round-tripping

The builder can also read a formula back into its visual form. Open the Visual Builder over a cell that already contains a supported formula and Formula Foundry will try to parse it back into fields — so you can tweak it visually and re-insert.

Tips

• Use the Visual Builder to learn syntax — the live preview is a working cheat sheet.
• After inserting, open the same cell in the Editor if you want to fine-tune the formula further.
• Custom variables work inside Visual Builder fields — they’re substituted at insert time just like in the Editor.