Most healthcare software companies treat claims integration as an engineering ticket. It is not. It is the mechanism that converts delivered care into cash, and the decisions around it are made — or avoided — by people who will never read an X12 specification.
This is the version of the conversation for those people. No segment names, no file formats. Just where the money is, where it leaks, and which decisions actually move the number.
Claims sit on the critical path to revenue
In most software businesses, revenue follows the contract. In healthcare, revenue follows the claim. Care is delivered, documented and coded — and then nothing happens financially until a correctly formatted claim reaches a payer and comes back adjudicated.
That gives claims integration a property very few engineering projects have: until it works, the money does not move at all. Not slower. Not partially. At all.
Three consequences that leadership consistently underestimates:
- Go-live is gated on it. A practice cannot switch to your platform until it can bill from your platform. Every week the integration slips is a week of delayed onboarding for every customer in the pipeline, not just one.
- Unbilled encounters accumulate silently. Care delivered but not billed does not show up as a loss. It sits as an absence. By the time anyone notices, some of it has aged past timely filing limits and is simply gone.
- It compounds across your customer base. A platform serving fifty practices carries fifty practices' cash flow on one integration.
The receivable that is not there
Here is the most expensive mistake in home-grown billing systems, and it is an arithmetic problem, not a technical one.
When an insurer pays a claim, the payment is not simply "less than you asked for". It breaks into parts, and one of those parts is money you agreed in advance never to collect.
A $200 session where your contracted rate with that insurer is $150:
- You billed $200
- The contract allows $150
- Insurance paid $120
- The patient owes $30 — copay or deductible
- The remaining $50 is a contractual adjustment
That $50 is not outstanding. It is not late. It is not collectable by working the account harder. It is the discount you accepted when you joined that insurer's network.
Systems that calculate "billed minus paid" report $80 outstanding when the real figure is $30. The number looks plausible. It reconciles to nothing, because nothing downstream checks it. And it is wrong on every in-network claim you process.
What that distortion causes:
- Overstated receivables on the balance sheet — a problem that surfaces during diligence, an audit, or a financing round, at the worst possible moment
- Billing staff chasing money that does not exist, which is pure wasted salary and erodes their trust in the system
- Collections activity aimed at patients who owe nothing, which is a patient experience problem and, depending on how far it goes, a compliance one
- Meaningless A/R aging reports, so nobody can tell which accounts genuinely need attention
If you take one thing from this article: ask whoever owns your billing system how the outstanding balance is calculated. If the answer is "charge minus payments", you have this problem today.
The two things that break timelines, and neither is engineering
Integration plans slip for reasons that never appear on an engineering roadmap.
Payer enrolment
Before you can bill an insurer electronically on behalf of a provider, that specific provider must be enrolled with that specific insurer — and separately for claims, for electronic remittance, and for eligibility checks. It is paperwork. It takes weeks. It is entirely outside your control.
A technically flawless integration cannot bill an insurer the provider is not enrolled with. Teams routinely finish the build and then discover they are eight weeks from revenue for reasons no engineer can fix.
Network allowlisting
Clearinghouses restrict connections to registered addresses. Your servers must be added before you can send anything at all — including your first test. Multi-day lead time, and it must be requested before you need it rather than when you are ready.
Both of these should start in week one of the project. They cost nothing to begin and they are the two most common reasons a "six week integration" becomes a four month one.
Three commercial questions that constrain the architecture
These look like procurement details. They are architecture decisions in disguise, and getting them wrong is expensive to unwind.
Is the clearinghouse account per-platform or per-practice? Most contracts are negotiated per software platform, with one account submitting for many practices. If your team assumes per-practice and builds credential management accordingly, that work is wasted.
Is real-time API access included, or only batch file exchange? Real-time access is frequently a separate paid product line. Teams scope features around it, then discover it is not in the contract. Confirm entitlement before anything is promised to customers.
Which payers does this clearinghouse reach well? Coverage is not uniform. If a meaningful share of your customers' volume goes to payers your clearinghouse handles poorly, you will feel it in rejection rates rather than in the contract.
Build, buy, or partner
The real question is not cost. It is time to first paid claim, and who controls the rail afterwards.
Building in-house gives you full control and the best long-run margin. The cost is that your team learns claims processing on your money, and the mistakes are financial rather than cosmetic. Reasonable when claims are core to your product and you can absorb a longer runway.
Buying an off-the-shelf billing vendor is fastest to revenue and slowest everything else. You are renting someone else's rail, usually per claim, and your roadmap becomes partly theirs. Reasonable when billing is a checkbox rather than a differentiator.
Partnering on the build keeps ownership while importing the experience. You own the integration and the margin; the mistakes have been made already, somewhere else. This is the common shape for platform vendors who need to own the rail but cannot afford to learn it slowly.
The question that decides it: is claims processing something your customers buy you for, or something they assume works? If it is a differentiator, own it. If it is table stakes, optimise for time to revenue.
What good looks like operationally
Once live, a healthy claims operation is visible in a handful of numbers. If your team cannot produce these on demand, the integration is not finished regardless of what the roadmap says:
- Claims awaiting transmission — anything sitting here is unbilled care
- First-pass acceptance rate — the share accepted without rework. The single best indicator of data quality upstream
- Claims with no payer response past a threshold — these are the ones that go quietly missing
- Denial rate by payer and by reason — denials cluster, and clusters are fixable
- Days in A/R, calculated on genuinely collectible balances rather than inflated ones
- Unreconciled payments — money received that has not been matched to a claim
Notice that most of these are about knowing, not about processing. The expensive failures in claims are rarely dramatic. They are claims that sit in a state nobody is watching, until the filing deadline passes.
Questions to ask before you commit
Whether the work is internal or with a partner, these separate teams who have done this from teams who have read about it:
- How is the outstanding balance calculated, and does it exclude contractual adjustments?
- What happens when a submission fails midway — can it create a duplicate claim?
- How do we learn a claim's status if the payer sends nothing? Do we actively ask?
- Where is the audit trail, and can it reconstruct a claim's full history two years later?
- What is the plan for payer enrolment, and when does it start?
- If we changed clearinghouse in three years, how much of this is rework?
Vague answers to any of these are worth more scrutiny than an aggressive timeline.
The short version
Claims integration is a revenue system that happens to be built by engineers. Treated as a technical task, it produces software that submits claims and a finance function that cannot trust the numbers. Treated as a revenue system, the technical work is the easy half.
Get the money model right, start the paperwork early, decide deliberately whether you own the rail, and measure the things that reveal claims quietly going nowhere.
Take the checklist with you
We have put the diligence questions above — plus the enrolment and allowlisting timeline, the contract questions, and the operational metrics — into a one-page Claims Integration Readiness Checklist. It is written to be taken into a vendor conversation or an internal planning session. Request the checklist and we will send it over.
If you would rather see the engineering detail underneath all of this, our technical guide to clearinghouse integration covers the transaction flow, the failure modes and a reference architecture.
Nirmitee builds claims and revenue cycle capability into healthcare platforms, and connects them through our healthcare interoperability solutions practice. Talk to our team about where your integration stands.
