All 6 payment methods in one place so payment isn't a mystery

Payment used to be a mystery

We take money six different ways - card, bank transfer, e-check, Zelle, cash or check in the field, and financing. Every one lands somewhere different. So a simple question - did this customer actually pay? - meant somebody checking six places by hand, with no single screen you could trust. Getting paid was never the problem. Knowing who had paid was.

One place for every dollar that comes in

So we built one dashboard that pulls every channel into a single view - who paid, how, and what's still owed. It's not a rip-and-replace: it's a screen inside the app the team already uses, wired to the systems we already had - the card processor, the bank feed, and the accounting software. No more logging into five systems to answer one question. The office opens one screen and sees the whole picture at a glance. Payment went from a scavenger hunt to something you just look up.

One balance the whole office can trust

The dashboard shows one balance, and every screen reads from it - no more three systems quoting three different numbers for the same customer. The rule that makes it trustworthy: our accounting system owns the truth about what's owed, and the app reflects it. If the books say a customer is square, the app agrees, everywhere. One number, and it's the right one.

It double-checks itself, so money can't hide

Payment systems tell you money came in by firing a webhook - but webhooks miss, from a wrong setting, an outage, or an event they never send. So the dashboard doesn't trust them alone: a poller and a nightly sweep independently check the account and catch anything that slipped through. The first time that safety net ran, it surfaced about $53,000 in payments that had already cleared into the bank but hadn't landed on anyone's balance yet - money that was always ours, now finally visible in one place. Belt and suspenders, on purpose.

The honest part - we almost made it worse first

This didn't go smoothly at first. Early on, we let the app keep its own copy of the truth about payments, and it drifted from the books. For a stretch, customers landed on the collections list who had already paid us - exactly the kind of thing that burns trust. We also built a whole new matching engine, around 2,500 lines, before deciding it was the wrong design and scrapping it the same day. The bumps were real, and the lesson they taught is the one worth keeping.

In trying to create clarity, we accidentally created a competing record of payments - one that needed constant re-syncing between the CRM and the field-service app.

One source of truth for money. Always.

Here's the rule we'd give any owner before they build anything near money: decide who owns the truth first. One system changes the number, one source holds it, and every app you build reads from that source instead of keeping its own copy. Get that right and a dashboard like this is a weekend of clarity. Get it wrong and you've signed up for a lifetime of re-syncing. Put the smarts into finding the stuck payments - and leave the truth where it already lives.

One system changes the data, one source of truth holds it. Your apps go through those. They never keep their own copy.