Real-Time Payment Posting in AI-Driven RCM Systems

What the denial landscape looks like in 2025 and 2026

ACA marketplace insurers denied 19.1% of in-network claims in Plan Year 2024, about 8.8 million rejected claims out of 46 million submitted across HealthCare.gov states, according to CMS Transparency in Coverage data. That's down from 22.5% in 2023, the largest single-year drop on record. The improvement flattens a spread that matters more than the average, and that makes it misleading. Some payers moved a lot. Others barely moved at all, and the gap between them is where a practice's actual risk lives.

Kodiak Solutions puts the initial denial rate at 11.6% in its most recent figures, up from 11.4% the year before, which is a small move but the wrong direction. Whatever the CMS marketplace number suggests about progress, the underlying trend across other data sources is upward.

The payer-by-payer spread turns this from an abstract industry trend into a practice-specific problem. Oscar Health denied 25.3% of claims in the CMS Plan Year 2024 data. UnitedHealthcare dropped from 33% to 20% year over year, which reads as progress until you remember it started at one in three claims denied. Kaiser Permanente sat at roughly 6%. A practice leaning heavily on Medicare Advantage or Oscar-administered plans is working a fundamentally different denial environment than one whose book skews Kaiser, and no amount of internal process discipline changes that exposure. Payer mix sets the ceiling. Everything a billing office does well or badly happens beneath that ceiling, not above it, and pretending otherwise is how practices end up blaming their own staff for a problem that's actually about which contracts they're running.

Kodiak's VP of Revenue Cycle Intelligence has been blunt about the mechanism behind these numbers: payers use initial denials to slow payment, even though they end up paying roughly 90% of claims eventually. Sit with that. The denial usually functions as a stall tactic dressed up as a coverage question. It's a stall tactic, and the practice absorbs the float cost while the claim sits in appeal, working capital tied up in a fight the payer already expects to lose.

The grounds for denial keep rotating, too, which is what makes this hard to build a fixed process around. Authorization-related denials fell 7.7% in Kodiak's May 2025 data, while medical necessity denials rose 5% and requests-for-information denials rose 5.4%. Payers are shifting toward categories that are harder to predict and harder to template a response for, and that shift looks deliberate rather than incidental. More than half of denied claims, 54.3% according to the AHA's citation of Premier, eventually get overturned on appeal. That number sounds reassuring until you count the rounds of appeal it takes to get there, each one burning staff hours the practice never recovers.

None of this is random. Denial behavior clusters by payer, by category, by time window, and a billing operation that reads those clusters the moment a claim posts has a real shot at responding before the appeal clock runs out. One that waits for the monthly aggregated report is already negotiating from a weaker position, and no amount of appeal-writing skill makes up for the days already lost.

How real-time posting differs from automated posting

Vendors use "automated" and "real-time" as if they're interchangeable, and they aren't. A system can ingest ERA files and apply payments in scheduled batches, hours or a full day after receipt, and still market itself as automated posting. That's automation running on a delay. The delay is where the damage happens, not the automation itself.

Real-time posting means payment and adjustment data flows into the system the instant the ERA is received. Every denial code, every adjustment reason, every contractual variance gets logged and made visible as it occurs. The practical difference appears in specific places. Denials become visible the moment they land instead of at a Friday reconciliation. Underpayments get flagged before the claim ages out of its appeal window. Zero-pay claims, acknowledged by the payer but paid nothing, appear in the queue right away instead of sitting quietly for weeks. Secondary billing and patient balance triggers fire on the correct day instead of whenever someone gets around to running the batch.

None of that works without a layer that separates clean transactions from ones that need a human. A real-time system splits auto-postable payments, where the amount matches the contracted rate and the claim data lines up, from the exceptions that actually require judgment. AI absorbs the routine volume so billers only see what genuinely needs a decision, which is the entire point: judgment is the scarce resource here, not typing speed.

The parsing that causes this difficulty is harder than it sounds. ERA formats aren't standardized across payers, some payers still send paper EOBs, and denial codes are frequently buried inside adjustment fields that need interpretation before they mean anything. A posting system has to handle all of that variation and still produce a consistent signal on the other end. This is where AI-driven parsing earns its place, rather than functioning as a label stuck on a legacy workflow that still runs on nightly batch jobs.

An HFMA study found that revenue cycle leaders name payer challenges, prior authorization, and workforce shortages as their top sources of stress. Read that against how posting actually gets handled and the real bottleneck comes into focus: format variation, combined with the absence of a mechanism that acts on what posting reveals in the moment it's revealed, not weeks later.

Once posting is genuinely real-time and exception-aware, it stops functioning as a ledger entry. It becomes a live feed of payer intelligence, and that's a different job.

The feedback loop real-time posting creates across the rest of the revenue cycle

Every posted transaction carries structured information: what the payer paid, what it adjusted, what it denied, and on what stated grounds. Stack enough of those transactions together and they produce a live map of how a payer actually behaves, as distinct from how its provider manual claims it behaves.

A spike in RFI-based denials from one payer becomes visible in posting data earlier than it would through periodic AR reporting. That gap is the window where staff can start attaching supporting documentation proactively to the next batch of claims headed to that same payer, instead of discovering a month later that an entire batch needs rework. Underpayment patterns by payer and procedure code accumulate transaction by transaction, and an AI layer can flag when a specific payer is consistently reimbursing below the contracted rate on a given claim type. That gives the contract enforcement conversation actual data behind it, instead of leaving it a hunch nobody can prove. Zero-pay claims posted in real time drop into a denial work queue immediately instead of aging unworked, keeping the appeal window open. Front-end eligibility checks and prior authorization documentation can get adjusted the moment posting data shows a particular authorization type getting denied at an elevated rate by a particular payer.

The effect compounds. Each cycle of real-time posting sharpens the next cycle's claim quality, because the system learns which claim characteristics correlate with denial or underpayment for a given payer, and it raises that risk earlier instead of after the money's already gone out the door and come back short.

There's an institutional-memory piece here too. Denial and payment behavior isn't uniform across payers, and a practice accumulating posting data by payer builds specific, durable knowledge of how each one operates. That knowledge is often held by individual billers, and when it isn't captured in the system, it can disappear when staff turn over. Kept in the system instead, it doesn't.

Batch posting technically has access to the same denial information. It just arrives aggregated, stripped of context, and often too late to act on inside the original claim's appeal window. Go back to Kodiak's finding that payers use initial denials to slow payment even when they intend to pay eventually. A practice running a real-time feedback loop catches that pattern faster, works the appeal faster, and shrinks the delay the payer was counting on in the first place.

Underpayment detection when posting is connected to contracted rate data

Underpayment is a different animal from denial, and arguably the more dangerous one, because the claim pays, the account closes, and the loss disappears from view unless someone checks the posted amount against the contracted rate at the exact moment it posts. Nobody's chasing a zero-pay claim here. That's what makes it worse: the transaction looks resolved.

The usual culprits are familiar to anyone who's audited a fee schedule: a payer applies the wrong rate, bundles procedure codes it shouldn't, uses an outdated contracted amount, or downcodes the service level. Every one of these produces a payment that looks entirely legitimate on its face. Nothing about the transaction flags itself as a problem unless someone measures it against the contract line by line, and almost nobody does that line by line, by hand, at scale.

A real-time posting system connected to the practice's actual payer contracts can run that check automatically: calculate the expected payment at the moment of posting, and flag any transaction where the received amount falls short. Skip that check and the underpayment gets posted as a routine contractual write-off. The account closes. The revenue is gone, and it's gone in a way that never appears as a denial or an aging problem anywhere in standard AR reporting.

The damage builds quietly rather than dramatically. Underpayments stack across hundreds of claims a month, and no single transaction looks alarming on its own. The aggregate effect instead appears as a slow, unexplained drop in net collection rate. A typical net collection rate runs 90 to 95%, with high performers at 95% or above, and that metric exists specifically to catch inefficiencies like this one. A practice not catching underpayments at the point of posting watches that number erode with no obvious cause anywhere else in its reporting.

A payer underpaying systematically on a given procedure category is very likely doing it across every practice it covers, not just one. That means a practice with historical, payer-specific posting data is presenting evidence when it raises the issue. It's showing evidence for a contract dispute the payer can't easily wave off.

AI's impact on what is possible in payment posting specifically

The problem AI solves in posting is volume and inconsistency. ERA and EOB volume outpaces what any team can review line by line. Format variation across payers breaks naive parsing logic, and denial codes are inconsistent enough that they need interpretation before they can even be routed to the right queue.

What AI actually does, concretely: it ingests ERA files from multiple payers in non-standard formats and maps each transaction to the correct claim and patient account without a person doing it by hand. It reads adjustment reason codes and classifies denials by type, medical necessity, RFI, authorization, eligibility, timely filing, and routes each to the workflow built for it. It applies contracted rate logic at the point of posting so underpayments get flagged without a biller cross-referencing a fee schedule manually. It opens a denial queue entry the instant a zero-pay claim lands. And it catches patterns across posted transactions, a payer running elevated RFI denials on one procedure code over a two-week stretch, well before that pattern would appear in a monthly report.

None of this removes the need for people, and it shouldn't. AI handles high-volume, rules-based posting accurately, but exceptions, non-standard adjustments, contractual disputes, unusual denial codes, still need to land in front of billing specialists who know how a given payer actually behaves. Payer behavior isn't fully rules-based, and it doesn't hold still. Payers rotate denial tactics, as the shift toward RFI and medical necessity denials shows, and the pattern-recognition layer only works if it's paired with people who can read what a new denial type means for that specific payer and decide how to respond.

An AI system builds payer-specific posting history across every claim it touches, and that history doesn't leave when a staff member does. Accuracy compounds as transaction volume grows, instead of resetting every time someone in the billing office quits and takes their payer knowledge with them.

Payers aren't standing still on their end, either. RFI-triggered denials rose significantly between 2022 and 2024, and payers increasingly use their own automation to generate and issue denials at scale. A practice whose posting system can't classify and route those denials in real time is already behind the payer's machinery, not just behind its own workload.

The AR and cash flow consequences of posting latency

Days in AR is the metric posting latency degrades most directly, and it does it quietly until the aging report tells an ugly story all at once. Industry benchmarks cite fewer than 40 days in AR as standard, with high performers doing better still. Every day a denial sits unposted or unworked adds a day to that clock, and the clock doesn't run backward.

Run the arithmetic on one claim. A denial that posts in a batch run on day seven, when it should have been visible and actionable on day one, is now six days closer to the timely filing deadline. Multiply that across a multi-payer practice running batch posting and the outcome is a systematic conversion of workable denials into eventual write-offs. A commonly cited benchmark holds that claims older than 90 days should make up a small fraction of total AR, and denied claims that don't get worked promptly are the fastest route past that threshold.

Reworking a denied claim costs money before a single dollar comes back. Reworking a denied claim carries a meaningful per-claim cost that scales with complexity. Medicare Advantage claims run $47.77 to rework specifically, which stings more given MA denial rates were running highest among the categories tracked in the AHA and Premier data.

Posting latency doesn't just slow individual claims down. It delays the signal that should tell a practice to change its claim submission behavior, so new claims carrying the same denial-prone characteristics keep going out the door while the old ones sit unworked in a queue nobody's watching. Tie that back to net collection rate: hitting 95% or above reflects strong overall collection performance, and posting latency erodes that number by letting recoverable denials age quietly past the point where they could have been fixed.

What a real-time posting workflow end to end delivers for practices

The workflow starts with ERA ingestion. The system receives remittance files from the clearinghouse or directly from payers and starts processing on receipt.

From there, auto-posting takes the clean cases. Transactions where the payment amount matches the contracted rate, the claim data lines up, and no denial code is attached, post straight to the patient account without anyone touching them.

Everything else goes through exception triage, and this is really the heart of the system. Transactions that don't post cleanly get classified by exception type and routed to the queue built for that type. Denials land in a denial queue sorted by category, medical necessity, RFI, authorization, eligibility, timely filing, with the appeal deadline visible right on the entry. Underpayments land in their own queue, flagged with the exact dollar variance between what was received and what the contract calls for, alongside the relevant contract reference. Zero-pay claims get their own queue too, so they never sit unnoticed the way they would inside a batch system.

That's the whole point of building posting this way. The information a practice needs to fix its denial rate, close its underpayment gap, and keep AR days down was always sitting inside the remittance data. Real-time posting is just the mechanism that stops letting it go to waste.