Lunch Money Alternative: Self-Hosted Spreadsheet Workflow

Quick answer. Lunch Money’s rules engine - the merchant-string-to-category mapping that auto-files transactions - is the feature most people assume cannot be rebuilt in a spreadsheet. It can, in roughly twelve lines of formula. Once that workaround clicks, the rest of Lunch Money’s workflow (review queue, multi-currency, tags) drops into Sheets cleanly. Pricing: Lunch Money is $10/month or a pay-what-you-want annual plan starting around $50; the Monthly Budget Template is $19 once.

Lunch Money has a small, devoted user base for a reason. The product makes one strong design choice: nothing posts to your budget until you, the human, look at it. That attracts people who would rather audit a hundred rows than trust an algorithm.

This is not a takedown. It is for the cohort that already likes the workflow but wants out of the subscription, or runs accounts in more than one country and wants the math in a file rather than a vendor’s database. The parts that make Lunch Money distinctive port to Sheets cleanly because the underlying logic is itself spreadsheet-shaped.

The Lunch Money workflow in one sentence

A rules engine auto-files transactions into a pending queue you review before anything touches the budget. Everything else (multi-currency, tags, an open API) is supporting cast around that one loop.

The two pieces of the spine, in slightly more detail:

• Rules engine. Each rule is a match this string -> assign this category pair, evaluated in order. Auditable, editable, no learning model. Closest mainstream analogue: Gmail filters.
• Review queue. New transactions arrive in pending. Nothing affects budget totals until you click through.

Two more reasons power users stay: more than 160 currencies with historical exchange rates (a 2024 EUR transaction converts at the 2024 rate, not today’s), and tags that sit on top of categories so reporting can slice across the tree without restructuring it. Plus an open API and a CSV-everything stance - the team treats portability as a feature, not a concession.

All four port to Sheets. The rules engine is the load-bearing one, so it goes first.

What the subscription costs

Lunch Money runs a pay-what-you-want annual model. The floor is roughly $50, the listed sticker is $100, and some users pay more. Monthly billing is a flat $10. There are no feature tiers - everyone gets the same product at every price.

Over time:

For someone opening the app daily, $100/year reads as a fair spend. For someone who opened it twice last quarter, the annual renewal becomes the moment to ask what it is doing.

The Sheets workflow at a glance

Four tabs cover what Lunch Money does.

1. Transactions. One row per transaction, with a Status column (pending or reviewed) and an optional Currency column.
2. Rules. A two-column lookup of merchant strings to categories.
3. Review queue. A filtered view of Transactions where Status = pending.
4. Categories. Category name, group, and a monthly target.

Setup from scratch is roughly 90 minutes. From the Monthly Budget Template it is closer to 15. Ongoing time is 10 to 20 minutes a week, the same range as actively reviewing a Lunch Money queue.

The rules engine in Google Sheets

This is the load-bearing section. The other three Lunch Money pieces (review queue, multi-currency, tags) are simpler ports. If the rules engine in twelve lines of formula does not convince you, nothing further in this article will.

Start with a Rules tab. Two columns: a substring to match against the payee, and the category to assign.

In the Transactions tab, the Category column becomes a formula instead of free text. The cleanest version uses INDEX / MATCH with a SEARCH wrapper, so each row scans the rules list and returns the first match:

=IFERROR(
  INDEX(Rules!B:B,
        MATCH(TRUE, ISNUMBER(SEARCH(Rules!A:A, B2)), 0)),
  "Uncategorized"
)

B2 is the payee cell. SEARCH returns a number when the rule string appears in the payee, and an error otherwise. ISNUMBER converts that into TRUE/FALSE. MATCH finds the first TRUE. INDEX returns the matching category. Anything that does not match a rule falls through to “Uncategorized” for you to look at on Friday.

One refinement worth knowing. Wrapping the column in ARRAYFORMULA lets every new pasted row auto-categorize without dragging the formula down:

=ARRAYFORMULA(
  IF(B2:B="", "",
    IFERROR(
      INDEX(Rules!B:B,
            MATCH(1,
                  IFERROR(SEARCH(TRANSPOSE(Rules!A2:A), B2:B), 0) * 1 > 0,
                  0)),
      "Uncategorized")))

You maintain one header cell and the column takes care of itself.

Unlike an AI categorizer, every assignment is auditable. Click the cell, read the Rules tab, see the rule that fired. Wrong assignment? Edit one row in Rules, and every past and future transaction with that payee updates on recalculation.

The review queue in a spreadsheet

Lunch Money’s review queue gates new transactions until you approve them. The Sheets version is a Status column with two values - pending and reviewed - and a filtered view.

Transactions arrive with pending by default. The default formula in the column is =IF(A2="", "", "pending") so any new row tagged with a date inherits pending status. As you work through the queue, you flip rows to reviewed.

A Review Queue tab is a single QUERY:

=QUERY(Transactions!A:G,
       "SELECT A, B, C, D, E
        WHERE G = 'pending' ORDER BY A DESC", 1)

Filtering on the source tab works too, but a dedicated QUERY tab keeps the review process out of the main log. Reporting formulas can also reference WHERE G = 'reviewed' so pending transactions stay out of budget totals until you sign off. That is the core Lunch Money design choice, replicated in one column and one filter.

Multi-currency without leaving Sheets

Lunch Money’s multi-currency handling is unusually good, and the spreadsheet equivalent is useful for anyone running international accounts.

A Currency column on the Transactions tab carries the original currency code. A second column holds the home-currency amount, computed at the rate that applied on the transaction date:

=D2 * GOOGLEFINANCE("CURRENCY:" & E2 & "USD", "price", A2)

D2 is the original amount, E2 is the currency code, A2 is the transaction date. GOOGLEFINANCE returns the historical rate for that date, which matches Lunch Money’s behaviour for old transactions.

Two caveats. GOOGLEFINANCE covers most major currencies but not every minor one, and the historical-rate function can return a small array (date and price) rather than a single number; in that case wrap with INDEX(..., 1, 2). For currencies GOOGLEFINANCE does not handle, a manual Rates tab with monthly snapshots covers the gap.

Tags alongside categories

Lunch Money lets one transaction carry one category and any number of tags. The Sheets version is a Tags column with comma-separated values. To total spend by tag, a SUMPRODUCT pattern works:

=SUMPRODUCT(ISNUMBER(SEARCH("Tokyo-2026", G2:G)) * D2:D)

That sums the amount column for every row whose tag column contains the target string. Reports can slice by category, by tag, or both, without restructuring the category tree. Not as smooth as Lunch Money’s tag UI; functionally equivalent.

The one thing Sheets cannot match

Lunch Money has a polished, focused web UI built by a small team that ships consistently. The spreadsheet does not. No roadmap, no changelog, no “they fixed the recurring chart bug last Tuesday.” You are trading active product development for a static workbook that does exactly what you set it up to do.

For some users that is a feature - the software stops moving, and the workflow stays put. For others it is a real loss, especially if the Lunch Money team’s design taste was part of why the app worked at all.

When Lunch Money still wins

Four situations where switching would lose value.

You use the review queue daily. Lunch Money is built around that gated review. If you click through pending transactions every morning with coffee, the UI is built for it and the spreadsheet is not.

You run accounts in three or more currencies. The historical-rate handling is better than what most casual Sheets users will set up, and the difference compounds with daily use.

You value the API. Lunch Money’s open API is rare in this category. Scripts you built against it do not port without rewriting.

You like the product taste and want to keep it shipping. Indie software with a small team needs paying users. “I would pay $100/year to keep this team going” is a coherent reason on its own.

If two or more of those fit, the subscription math gets a lot easier to defend.

When the spreadsheet wins

The queue piles up and you batch-approve on Sundays anyway. If your real behaviour is weekly bulk review, the Sheets version already matches it.

The recurring cost stopped feeling like value. $100/year over a decade is $1,000. Break-even on a $19 template lands around 10 weeks at the annual tier.

You want the math visible. Every term in the rules engine, the review queue, and the currency conversion is a cell you can click. App-level math is mostly closed.

You want categorization without vendor updates. A rules tab is readable by anyone who can read a row. AI categorization mostly is not.

Same trade we covered in the Copilot Money alternative walkthrough: automation for cost, ownership, and flexibility.

Comparison: Lunch Money vs Sheets vs FinancialAha template

Lunch Money wins on the polished review-queue UX and the unusually strong multi-currency story. Sheets wins on cost, ownership, and the fact that every formula is yours to edit.

Migrating from Lunch Money

If you want to test the spreadsheet workflow without losing history, the path is short.

1. In Lunch Money, export transactions as CSV (full export, no row limit).
2. Open the Monthly Budget Template and paste the CSV into the Transactions tab. Column order may need a one-time rearrangement.
3. Build the Rules tab from your existing Lunch Money rules. Most accounts need 10 to 30 rules to cover the bulk of recurring transactions.
4. Run both tools in parallel for one cycle. At month-end, compare what each captured and decide which to keep.

The transition usually takes a weekend afternoon. The friction is the habit change, not the data move.

Templates that fit this

If the rules engine + review queue from this article is what you want to drop into a finished file, the Monthly Budget Template ($19 once) has the transactions tab, categories, planned vs actual, and a dashboard already wired. The Rules tab and ARRAYFORMULA above paste in directly.

For the first month or two while you build up the rules list, some people prefer the lighter Monthly Expense Tracker ($15) - a clean log with category totals and no monthly targets to wrestle with yet.

Related

• Copilot Money Alternative: Build the Same Workflow in Google Sheets
• YNAB Alternative in Google Sheets: The Method, Mapped Cell by Cell
• Tiller Alternative: Google Sheets Budgeting Without the Subscription