2026-09-20 · marketing ops · architecture · 6 min

The sheet is neat: why my $2.3M attribution pipeline runs through a Google Sheet

The ad platform was optimizing on garbage signals, so I built a closed feedback loop to teach it which clicks become customers. The most contested design decision in the whole system was the most boring one: a spreadsheet in the middle. Boring won, and it keeps winning. Here is the argument.

The problem: every form-fill looked like a win

I run marketing for a manufacturer that sells premium custom-built products through a dealer network. When I inherited the ad account, its conversion signal was effectively "someone filled out a form." To a bidding algorithm, a homeowner planning a five-figure purchase and someone asking about a spare part looked identical. Google was cheerfully optimizing toward whoever was easiest to make fill out a form, which is not the same population as people who buy things.

The fix is well known in principle: feed the platform offline conversions, so it learns from real outcomes instead of form submissions. The interesting part is the plumbing, because in practice almost nobody at small-business scale actually builds this loop.

The loop

form → webhook → database + click ID → human qualification UI → audit-logged sheet → nightly ads import

Every submission lands in a database with its ad click ID attached. A small internal dashboard shows new leads; a human (me) qualifies or disqualifies each one, because judging lead quality is exactly the kind of consequential judgment that should stay human. Qualified leads flow to a Google Sheet, and every night the ad platform ingests them as offline conversions. The bidding system stops learning "who fills out forms" and starts learning "who becomes a customer."

Downstream, the same click IDs let us match sales orders back to submissions deterministically: an order's customer matched on multiple identity fields against a form submission carrying a click ID. By that standard, the pipeline tracked more than $2.3 million in attributed sales orders from a single quarter, matched order to click, against roughly $4,000 in ad spend. That figure is a floor, not an estimate: it counts only orders the tracking could individually prove, and it is attribution, not a causal claim. Plenty of other factors sell products. The point is narrower and more useful: we know, order by order, which clicks the pipeline touched.

The contested part: why a spreadsheet?

Every engineer who hears this architecture asks the same question. The database talks to an API on one side and an ad platform on the other. Why is there a Google Sheet in the middle instead of a direct API integration?

Because the sheet is not a compromise. It won on the merits.

It is a human-readable audit log. When the ad platform ingests a conversion you did not expect, you open the sheet and look at the exact row your system wrote, with a timestamp. Debugging a direct API integration means archaeology in two vendors' logs. Debugging the sheet means reading the sheet.
It is lockable governance. Give management ownership of the sheet and lock it down: automated ingestion still flows, but now there is a tamper-evident record of what entered the ad platform, when, and from whom. A spreadsheet behind glass is a surprisingly robust compliance artifact.
It survives the vendor's whims. Direct offline-conversion uploads via the ads API require developer-token access that is genuinely painful to obtain, and the ingestion plumbing itself gets reorganized periodically. Scheduled imports from a sheet are the stable, officially supported, boring path. When the vendor reinvents the plumbing, the spreadsheet keeps flowing through the officially supported pipe.
Any business can operate it. No developer token, no OAuth ceremony, no engineer on retainer. If I disappeared tomorrow, the company could still see, audit, and control exactly what feeds their ad account.

The general principle, which I apply to every system I build: automate collection, transformation, and routing aggressively, but keep consequential judgment observable and human-accessible. The sheet is the observability layer. It costs nothing and answers questions forever.

The only real tradeoff is latency: conversions ingest nightly instead of instantly. For a considered purchase with a weeks-long sales cycle, six hours of bidding-calibration delay is a rounding error. I have yet to meet the business whose problem was that their offline conversions arrived at midnight instead of 6pm.

What this generalizes to

The pipeline is a specific instance of a pattern I see everywhere in small businesses: two systems that each work fine, connected by a human doing copy-paste, with all the judgment and none of the record-keeping. The automation opportunity is rarely "replace the human." It is almost always "capture the data properly, route it automatically, keep the human for the one decision that matters, and leave an audit trail a non-technical owner can read."

Sometimes that means a webhook and a database. Sometimes it means thirty lines of script. And sometimes, genuinely, the best middleware money can buy is a spreadsheet that costs nothing, breaks never, and explains itself.

The sheet is neat.

Jarrod Mays builds internal tools, integrations, and workflow automation at Forgelit Systems, and free privacy-first utilities at Forgelit. If your business has a workflow held together by copy-paste, he would genuinely like to see it.