Payments

Payment systems that reconcile at the end of the month

Taking money is easy. Taking it reliably, refunding it, invoicing it, and proving where it went is the actual work.

I've built payment infrastructure on three different kinds of rails — a card gateway processing over $1M a year (annualized), Stripe subscription billing for my own SaaS products, and an open-source cryptocurrency gateway for WooCommerce. Different rails, same hard parts: webhooks that arrive twice, states that get stuck, and edge cases that only show up with real money.

$1M+
A year in payments, annualized
3
Payment rails: cards, subscriptions, crypto
2
Open-source payment packages published
90%
Faster contract turnaround via e-signatures

Scope

What I integrate

Stripe billing & subscriptions

Checkout, subscriptions, plan changes, proration, failed-payment recovery, and the webhook handling that keeps your database agreeing with Stripe's.

Meshulam & Israeli gateways

Full Meshulam SDK integration including tokenization, recurring charges, and invoice generation — built into a Strapi backend and running in production.

Custom WooCommerce gateways

When your processor has no plugin, or the one that exists is abandoned. Written to the WooCommerce gateway API properly, so refunds and order states behave.

Cryptocurrency payments

Non-custodial crypto acceptance where funds go straight to the merchant's own wallet. Address derivation, confirmation monitoring, and order reconciliation.

Invoicing & documents

Automated PDF invoice generation, e-signature flows, and the document trail your finance team and auditors will ask for.

Rescue & reconciliation

Payments landing but orders not updating. Duplicate charges. Webhooks silently failing for three weeks. I find it and fix it.

Proof

Systems handling real money

Meshulam + Strapi — $1M+ per year, annualized

At One Digital I built an end-to-end payment system on the Meshulam SDK inside a Strapi backend, processing over $1,000,000 a year in transaction volume. The interesting half was never the charge call. It was everything that has to stay true afterwards:

  • Webhook reconciliation. Gateways retry. They deliver out of order, they deliver twice, and occasionally they deliver three weeks late. Getting a replayed webhook to update the order it already created, instead of creating a second one, is most of the work in any payment integration.
  • Lifecycle hooks as the single source of truth. Order state transitions live in Strapi lifecycle hooks rather than scattered through controllers, so a payment can't be marked paid down one code path and left pending down another.
  • Invoices generated automatically. Dockerized Puppeteer on Azure Functions renders the PDF invoice as part of the payment flow, not as a monthly chore, which is the difference between finance trusting the system and finance keeping a parallel spreadsheet.

Stripe — billing my own SaaS, in production

GhostChat runs on Stripe subscription billing I built and still operate. Two decisions there are worth stealing for any subscription product:

  • Entitlements resolve from the subscription itself. What a customer can do is derived from the Stripe price they're actually on, not from a plan name copied into your own database at signup. Those two drift apart the first time someone upgrades mid-cycle, and once they drift you are reconciling access by hand.
  • Repricing is a new Price, not a migration. Because entitlement is read from the subscription itself, changing what you charge means publishing a new Price object rather than running a script against live customers at 2am — and you decide deliberately, per entitlement, which existing subscribers move.

There is a particular kind of care you develop when the failed-payment webhook is your own revenue, and that's the standard I bring to client billing systems.

KaspaWoo — open-source crypto gateway

A production Kaspa payment gateway for WooCommerce, open-sourced on GitHub. It's non-custodial: payments derive to the merchant's own wallet, never mine. The address derivation had to be its own package because no lightweight JavaScript option existed — the official tooling is a WASM build far too heavy to sit inside a WordPress plugin — so I wrote kaspa-simple-wallet in pure JS and published it MIT: watch-only derivation from a KPUB/XPUB, Kaspium-compatible, so the store never holds a private key. It is written to the WooCommerce gateway API properly, which means refunds and order states behave the way the rest of the admin expects them to.

Why the non-custodial detail matters: a store that never holds keys can't lose them. Most payment bugs are really state bugs — and the best fix is usually an architecture where the dangerous state doesn't exist in your system at all.

E-signatures and contract flow

At Hertz Furniture I integrated SignNow for e-signatures on PDF quotes, cutting contract turnaround time by 90%. Payments rarely live alone — they sit next to quotes, contracts, invoices, and a CRM that all need to agree with each other.

Got a payments problem?

New integration, custom gateway, or something that's quietly broken and costing you orders — describe it and I'll tell you what it'll take.