There are two cost problems eating TPA margins that almost never appear in board decks. They do not show up as line items in your P&L. They do not trigger variance reports. They are baked so deeply into how TPA operations work that most leaders have stopped questioning them.
The first: the cost of building a health plan for a client who leaves in under three years. The second: the cost of employing claims specialists to answer eligibility questions that should be answered automatically.
Together, they represent a structural drag on TPA profitability that compounds every year as client churn increases and provider networks grow more complex. In 2026, the TPAs that are pulling away from the field have figured out how to attack both problems at once.
Part One: The Plan Build Problem
When a self-funded employer engages a TPA, the first major work product is the plan build: converting the employer's Summary Plan Description, benefit schedules, rider amendments, and coverage rules into the logic that governs every claim adjudication for the life of the relationship.
It is a labor-intensive process. Depending on plan complexity — number of covered tiers, custom carve-outs, coordination of benefits arrangements, stop-loss attachment points — a full plan build can consume 60 to 120 hours of skilled analyst time. At a blended analyst rate of $65 to $85 per hour, that puts a typical build between $4,000 and $10,000. Before QA, implementation testing, and the inevitable rounds of revision as the employer refines their benefit design.
The three-year cliff
Self-funded employer retention follows a pattern most TPA operators know intuitively but rarely quantify: the first two to three years are when churn risk is highest. The employer is still evaluating the relationship. Competitors are actively pursuing them. Brokers are shopping the account every renewal cycle.
When an employer leaves before the plan build cost has been amortized across enough years of administration fees, the unit economics of that relationship invert. You spent $8,000 building a plan that generated $4,000 in net administration margin before they left. The plan build alone consumed 28% of total relationship profit — before accounting for onboarding, implementation support, and account management.
"We price for a five-year relationship and lose money on clients who leave at year two. The plan build is the single biggest variable we cannot control — until we make it faster and cheaper to build."
This is not a niche problem. Every TPA is managing this exposure. Most are managing it the same way — by hoping clients stay long enough.
The compounding effect of plan amendments
The plan build problem does not end at onboarding. Most self-funded employers amend their benefit design at least once per year — changing deductibles, adding or removing covered services, adjusting network tiers, updating stop-loss parameters. Each amendment requires the plan build to be updated.
If those updates are made by editing configuration fields in a claims system without a systematic record of what changed, when, and why, you accumulate what is sometimes called configuration drift. The plan as documented diverges from the plan as adjudicated. By year three, the logical version of the plan and the document version may no longer be the same thing.
This matters enormously when you face a stop-loss dispute or a DOL inquiry. The question is not just whether a claim was processed correctly. It is whether you can demonstrate that it was processed according to the specific rule in effect on the date of service — and cite exactly where in the governing plan document that rule came from.
When plan logic and plan documents diverge, every audit becomes a reconstruction project. Analysts spend weeks tracing claim decisions back through system logs, trying to establish which configuration was active when. In stop-loss disputes, carriers exploit this gap. The cost is not just analyst hours — it is the disputes you lose because you cannot prove what you know to be true.
Part Two: The Eligibility Call Problem
The second structural cost sits in your call center.
Eligibility verification — confirming that a member is covered, identifying the relevant plan, establishing benefit levels and cost-sharing requirements — is one of the highest-volume interactions in healthcare administration. Providers need it before rendering services. Members need it before seeking care. And in most TPA operations, a significant portion of those inquiries are handled by phone.
Only 36% of TPAs have the infrastructure to respond to eligibility inquiries automatically. The other 64% are fielding these calls manually, at a fully loaded cost of $8 to $14 per interaction — including call center staffing, quality monitoring, supervisory overhead, and provider hold time.
| Eligibility Inquiry Type | Automated Cost | Manual Call Cost | Volume |
|---|---|---|---|
| Provider pre-service verification | $0.12 – $0.40 | $8 – $14 | High |
| Member benefit inquiry | $0.12 – $0.40 | $8 – $14 | High |
| Coordination of benefits check | $0.40 – $1.20 | $12 – $18 | Medium |
| COBRA / continuation eligibility | $0.40 – $1.20 | $12 – $20 | Low |
For a TPA handling 5,000 eligibility inquiries per month, automating 80% of that volume saves between $30,000 and $55,000 monthly — before accounting for improved provider experience and reduced downstream claims errors from faster, more accurate eligibility data.
Why the eligibility gap persists
The barriers to eligibility automation are not primarily technical. Most legacy TPA systems support some form of electronic eligibility response. The problem is that the underlying data — member enrollment records, benefit configurations, effective dates, coordination of benefits hierarchies — is often fragmented, inconsistently maintained, or embedded in the same plan build logic that is prone to configuration drift.
You cannot automate an eligibility response if you are not certain the underlying plan configuration is current and correct. The two problems share the same root cause: plan logic that is not version-controlled, reproducible, or machine-readable.
What the Highest-Margin TPAs Do Differently
The TPAs that have pulled ahead on profitability metrics are not necessarily larger, better at sales, or serving a more favorable market. The most consistent differentiator is how they manage plan logic.
They treat plan documents as source code
In software development, source control is table stakes. Every change is tracked, versioned, and attributed to a specific date. Rolling back to any prior state takes seconds. Leading TPAs have applied this same discipline to plan documents. Every SPD, every amendment, every benefit schedule lives in a single system of record. Every change is versioned and dated. When a claim is adjudicated, the system records not just the decision — but the specific version of the plan rule that governed it, with a citation to the relevant document section.
The downstream effects compound:
- Plan builds become faster because logic is modular and reusable across similar plan designs
- Amendments become surgical rather than requiring full configuration reviews
- Audits become answerable in hours because the decision record is already complete
- Stop-loss disputes become winnable because every claim is cited back to the governing document
- Eligibility automation becomes reliable because the underlying data is current, versioned, and machine-readable
They separate plan logic from claims processing
Legacy TPA systems conflate plan logic with claims processing. The rules that govern adjudication live inside the same system that executes it. This makes it difficult to audit either independently, and nearly impossible to reproduce a specific decision state from a prior date.
The structural shift leading TPAs are making: a separate plan logic layer that is versioned and auditable, independent of the claims engine. A claims processing layer that queries the logic layer for the rules in effect on the relevant date of service. This separation is what makes claim decisions fully reproducible under any audit condition.
A stop-loss carrier challenges a large claim from 14 months ago. Under the legacy model, an analyst spends two weeks pulling system logs and attempting to reconstruct the rule state at the time of service — with no guarantee of completeness. Under the versioned model, the answer is a single query: "Show me the plan rule in effect on this date, and the document section it was derived from." The complete audit package is generated in minutes.
The Path Forward
The two cost problems described here — plan build economics and eligibility automation — are not new. TPAs have been managing them for decades. What has changed is the availability of infrastructure that makes both genuinely solvable, rather than just manageable.
Version-controlled plan logic, machine-readable benefit configurations, and real-time eligibility data are now achievable without replacing your core claims platform. The architecture is additive: a layer that sits between your plan documents and your claims engine, converting language into logic and maintaining a complete, citable record of every decision.
The TPAs investing in this layer now are building a compounding advantage. Lower plan build costs. Higher eligibility automation rates. Faster audits. Fewer lost stop-loss disputes. And the ability to demonstrate to self-funded employer clients that their plan is being administered exactly as written. Every claim. Every time.
That is not a belief. It is a record.