Who Gets Paid, and When: Money Flow in Healthcare Platforms

Ask most healthcare software teams how money moves through their platform, and you will get an answer about Stripe. That is the plumbing. The question underneath it is harder, and it is the one that determines whether practices stay on your platform: who gets paid, how much, and when?

This is that conversation without the technical detail. Where the money comes from, why it arrives in pieces, what quietly goes missing, and which decisions actually change the number.

Teams that want this built rather than researched can work with our RCM software development team.

One visit, two payers, two clocks

A single appointment usually generates money from two entirely separate sources.

The insurer pays most of it — but only after the claim is submitted, adjudicated and remitted. That is weeks, and the exact amount is not known in advance.

The patient pays the rest — copay, coinsurance or deductible. That is days, if you collect at the time of service. It is months, or never, if you do not.

Two consequences that shape everything else:

• You cannot tell a practice what a visit earned until both have landed. Any number shown before that is an estimate, and it should be labelled as one.
• The patient portion is the part you actually control. The insurer pays what the contract says. The patient portion is collected or lost depending on how well your platform handles it.

Where the money quietly goes missing

Revenue leakage in healthcare platforms is rarely dramatic. Nothing breaks. Money simply does not arrive, and because it never existed as an invoice, nobody notices it is absent.

The patient portion nobody chased

The insurer adjudicates and assigns $40 to the patient. That $40 is now a receivable. If your platform records it but never prompts anyone to collect it, it ages quietly until it is written off. Across a practice's caseload, this is usually the single largest leak.

The card that failed once

Cards expire and get declined constantly. It is routine, not exceptional. But if a failed charge is treated as an error to log rather than a receivable to recover, that money is gone — for care that has already been delivered. There is no cost saving in not collecting it; the clinician has already been paid for their time.

The refund that was never reversed

A patient is refunded, but the clinician was already credited for that money in their compensation. If the refund does not flow back through earnings, the practice has paid for revenue it returned. Small per instance, systematic over time.

The chargeback nobody saw

A patient disputes a charge. The funds leave. If your platform does not track disputes, the money is gone from the practice's account while your reports still show it as collected.

The mistake that makes all of this invisible

Most platforms keep patient money and insurance money in separate places, because they arrive through different systems and are built by different people at different times.

The result is that no single screen shows what a visit actually earned. Finance sums one source, operations sums another, and the clinician's compensation statement uses a third. All three disagree, and there is no way to determine which is right — so people stop trusting the numbers and start keeping spreadsheets.

The fix is architectural and worth insisting on: one ledger, both sources. Every payment — insurer or patient, card or cheque — lands in the same record with its origin noted. Every report reads from it. When the numbers agree, people trust them; when people trust them, they act on them.

Whose money is it?

A question worth settling early, because it has legal and operational weight.

On most healthcare platforms, the practice delivers the care and holds the payer contracts. The money is theirs. Your platform routes it and retains a fee.

That distinction matters:

• Holding practice funds in your own account raises questions you do not want to answer, and makes you responsible for reconciling every practice's money by hand.
• Each practice needs its own payment identity — their bank account, their tax details, their payout schedule.
• Practices can leave. They can disconnect their payment account without telling you. Your platform needs to notice, rather than discovering it when a patient's card fails at reception.

What to measure

Six numbers tell you whether the patient side of your revenue is healthy. If nobody can produce them, that is itself the finding:

• Point-of-service collection rate — the share of patient responsibility collected at the visit. The single biggest lever, because collection rates fall steeply once the patient has left.
• Patient balance aging — how long assigned patient responsibility sits before it is collected or written off.
• Failed payment recovery rate — of charges that failed, how many were eventually collected. If this is near zero, you have no retry process.
• Unreconciled payments — money received that has not been matched to a visit.
• Dispute rate — rising disputes usually signal a communication problem, not a fraud problem.
• Time from visit to full payment — the true cash conversion cycle, counting both payers.

Questions worth asking your team

Whether the work is internal or with a partner, these surface the difference between a platform that processes payments and one that manages revenue:

• If a patient pays and immediately closes the browser, does the payment still get recorded?
• When a patient's card fails, what happens next — and who is responsible for it?
• If a patient is refunded, does the clinician's compensation reduce automatically?
• Can we see, for one visit, everything received from both the insurer and the patient in one place?
• What happens if a practice disconnects their payment account?
• Can we reconstruct exactly what happened to a payment eighteen months from now?

Hesitation on the first or the third is worth pursuing. Both point at money moving without being recorded.

Collections start before the visit: see Good Faith Estimate software for estimates that hold up against the EOB.

The short version

Healthcare revenue arrives in pieces, from two payers, on different clocks. The insurance half is governed by contracts you do not control. The patient half is governed by how well your platform collects, retries, and reconciles — and that half is where platforms differentiate.

Put both in one ledger, collect at the point of service, treat failed payments as revenue to recover rather than errors to log, and measure the six numbers above. None of that is exotic. It is just rarely done deliberately.