Every startup has a gap where money moves in one system and gets recorded in another. At Cantina, security researchers get paid through our platform. Our finance team tracks those same payments in Airtable. For a long time, the thing connecting the two was a person copying numbers across.

It worked, the way manual processes work: slowly, with a small error rate nobody could measure, and with a bottleneck named after whoever was on vacation.

This week we closed that gap for good. Here’s what we built and the design rules that made it safe, including the ones I only learned by breaking things.

One obligation, not one row per transaction

On the surface the job looked simple: when a payment goes out, mark it paid in Airtable.

But the two systems don’t count the same way. In our payments platform, one piece of work can produce several payments: a first installment, a second one, a payment that gets cancelled and re-issued with a corrected amount. In Airtable, finance thinks of it as one payment owed to one person for one engagement.

The first version of our automation treated every platform payment as a new Airtable row. That’s the obvious way to build it, and it’s wrong. A re-issued payment would have given finance two rows for one obligation, and someone would have had to work out which one was real.

So the rule became: many payments on the platform, one row in Airtable. Every payment for the same person and the same piece of work links back to that one row, and the row’s total and status are worked out from all of them.

Three rules for touching trusted data

Once the automation was writing to records finance relies on, the question changed from “can it update this?” to “what could it break?” We ended up with three rules.

  1. Never go backwards. The sync can raise an amount, but it never lowers one. It can move a payment from Partial to Paid, but never from Paid back to Partial. If Airtable ever shows more than the platform, a human looks at it. Monotonic updates mean the automation can’t quietly undo someone’s work.
  2. Notify, don’t overwrite. When a payment is cancelled on the platform, my first instinct was to void it in Airtable automatically. We changed our minds. A cancellation usually means someone is about to fix something, and by then finance may already have invoiced it. Now a cancellation changes nothing in the books. It shows up in a daily summary, and a person decides.
  3. Skip what you can’t be sure of. Some people have several rows on the same engagement, for example monthly work. The sync can’t know which row a payment belongs to, so it doesn’t guess. Those stay manual. An automation that handles 90% of cases correctly and hands back the last 10% is worth far more than one that handles 100% and gets 3% wrong.

Preview before permission

We shipped the new logic switched off for the part that touches existing records. Before turning it on, I reviewed a preview of exactly which rows would change, and how. That preview caught a real issue: in one case the rule would have marked a payment fully paid because of a number someone had typed in by hand, not because the platform had actually paid it. We fixed the rule before it touched a single record.

For any automation that edits data people already trust, this is the step I’d tell other operators never to skip: write down what it will change, read it, then flip the switch.

Read the run log, not the result

We tested. It still broke on its first real runs, in two ways I’d never have guessed:

  • A lookup silently returned less data than we asked for, because of how our automation tool handles a certain kind of request. Nothing crashed. Values just came back empty, and a later step failed quietly on dozens of records. The design rules above are why “failed” meant “wrote nothing” rather than “wrote garbage”.
  • One stuck failure blocked every run after it. A setting meant to keep runs in order also meant a single unresolved error could freeze the whole automation. We only noticed because I went looking.

The lesson isn’t “test more”. It’s read the run log, not the result. Both bugs were visible in the step-by-step log on the first day, and invisible in the data.

The judgment calls were operations calls

I don’t write code. I built this with Claude as a pair: I owned the decisions (what counts as one payment, what the automation may never touch, what stays human), and Claude handled the mechanics, then checked the live runs step by step with me. The judgment calls in this post were all ops calls, not engineering ones. That’s the part I think more operators should take on themselves.

Every morning, payments made through the platform show up in Airtable already reconciled: amounts filled in, statuses updated, re-issues linked to the right row. Anything unusual lands in one short daily summary. The process is written down in three places: an internal wiki page for the “why”, a step-by-step guide for the people who use it, and a short announcement that took about 30 seconds to read.

The automation is the part people notice. The part that will keep it working is those rules: one row per obligation, never go backwards, notify instead of overwriting, and skip what you can’t be sure of.