Monday, 7:30 a.m., the revenue cycle office of a mid-sized physician group. Four people open the same set of windows: the practice management system, a dozen payer portals, and a spreadsheet of claims that have been sitting unpaid for more than 30 days. Each line is the same routine: log in, search for the claim, read the status, copy it back, move on. At the last leadership meeting a vendor showed a slide: “Our bots do this overnight, error-free, payback in nine months.” The COO asks one question: is this the right process to start with?

Often it is not. Not because robotic process automation does not work, but because in healthcare the economics of a bot depend on something the slides rarely show: how long the screen it clicks on will survive, and who will catch its mistakes. This article is for COOs, revenue cycle leaders and administrative directors at hospitals, physician groups and healthcare services companies who are being offered RPA and need to decide where it belongs.

The thesis is simple, and some readers will disagree with it: in healthcare, RPA is a bridge, not a foundation. It pays off only where three conditions hold at the same time: the interface the bot works on will outlive it by at least two years; a later step will catch the bot’s errors before they reach a patient or a payer; and the task involves no clinical judgement. The use cases sold most loudly, such as prior authorization, medical coding and clinical documentation, usually fail at least one of these tests.

How is RPA different from integration and from AI in a healthcare setting?

Robotic process automation is software that imitates a person at a computer. It logs into applications, reads fields on screen, clicks buttons, copies and pastes data and sends emails. It needs no changes to the systems it uses and no work from their vendors. That is its main advantage and its main weakness: a bot is exactly as stable as the screen it is looking at. Where an interface exists, EHR integration over HL7 and FHIR is the better route, while regulated systems such as software as a medical device or telemedicine platforms carry their own constraints on any automation.

An API integration is something else. Two systems exchange data directly, in an agreed format, without pretending to be a person. US healthcare has had such standards for a long time: HIPAA-mandated X12 transactions for eligibility (270/271), claim status (276/277), prior authorization (278), claims (837) and remittance (835), and more recently HL7 FHIR APIs. In the EU, national e-health platforms play a similar role, and the European Health Data Space regulation pushes in the same direction. Integration takes more work to set up and usually involves the vendor, but it does not break when a button moves. For a wider view of systems integration and why interoperability is the hardest technical part of medical projects, see our article on healthcare software development.

The third category is AI: document recognition, classification, summarisation and, increasingly, language models that suggest a code or draft an appeal letter. AI does not replace RPA or integration. It adds a layer of judgement where a rule is not enough, and in healthcare that is the layer that needs the most careful design, because it fails differently from a person.

In practice the three appear together under the banner of process automation. For a leadership decision it pays to keep them apart, because each ages at a different speed and each fails in a different way. A bot stops working after a system update. An integration stops working when a standard version changes, but usually with notice. An AI model does not stop working; it starts being wrong, and nobody notices unless somebody is measuring.

Why does healthcare look like the perfect place for bots?

Because healthcare administration is dense with repetitive work at a screen. A provider runs an EHR, a practice management or patient accounting system, lab and imaging systems, pharmacy, finance and HR systems, dozens of payer portals and a clearinghouse. Many of these were bought separately, and people move the data between them. Every hour of that work looks like savings waiting to be collected.

The numbers are large. According to the CAQH Index 2024 key takeaways, the US medical and dental industry could save around USD 20 billion a year by moving to fully electronic administrative workflows, around 70 minutes per patient visit, and adopting the electronic standard for prior authorization would save providers 14 minutes per authorization and the industry USD 515 million a year. The CAQH Index 2025 executive report puts the medical provider’s average cost per transaction at USD 8.03 when manual and USD 2.65 when electronic.

Read those figures carefully, though. CAQH does not measure savings from bots. It measures savings from moving to electronic transaction standards, which is what this article calls integration. A bot clicking through a payer portal does not turn a manual transaction into an electronic one. It replaces a person clicking through a portal with a program clicking through a portal. Labour cost falls, but the fragility of the process stays, and sometimes grows.

The second trap is staffing pressure. Shortages in revenue cycle and front-desk roles are real, and RPA promises relief without hiring and without waiting for the EHR vendor. That is a powerful emotional argument, which is exactly why it is worth separating processes where a bot genuinely removes work from those where it moves work into IT as a permanent maintenance cost.

What three questions decide whether a process suits RPA?

The classic criteria for choosing RPA candidates are well known: high volume, repetition, clear rules, digital inputs, few exceptions. In healthcare they are necessary but not sufficient. We suggest three questions to ask before the classic criteria, because each of them can disqualify a process regardless of volume.

First: how long will the interface live? A bot is tied to specific screens in a specific version of an application. If the EHR vendor ships major releases twice a year, the payer is moving to a new portal and a regulator is mandating an API, the bot has a short life ahead of it. Estimate the interface’s lifespan before you calculate payback, not after.

Second: who catches the bot’s mistakes? A bot does not get tired or skip fields, but if a rule is wrong or a screen layout changes, it makes the same mistake hundreds of times, quickly and without hesitation. A process suits RPA when an independent check follows: a payer edit, a reconciliation in finance, a human review. It does not suit RPA when the error flows straight to a patient, into the medical record or to a payer with no gate in between.

Third: is there clinical judgement in the process? If a step requires medical knowledge, even when it is hidden in an “obvious” decision by a scheduler who knows that a particular patient must go to a different clinic, it is not a job for a rule. It may be a job for AI with a human in the loop, but that is a different project with different risk and different oversight.

Only once a process has passed these three questions is it worth counting volume, handling time and exceptions. The order matters, because volume is persuasive. A task performed 40,000 times a month looks like an obvious candidate even when the interface will disappear next year and the error goes unchecked to the payer.

Which revenue cycle and back-office processes are worth automating with a bot?

More than the cautious tone of this article might suggest. What they share: they are administrative, they run on interfaces nobody is about to replace, and they end in a check that will catch a mistake.

Claim status checks with the long tail of payers. Large payers support electronic claim status inquiries, but the 2025 CAQH Index shows that only 81% of medical plans reported claim status as fully electronic. For smaller payers, regional plans and some workers’ compensation carriers, the portal is the only channel. A bot that checks status on those portals and writes it back to the work queue is a sensible tool, because the result is informational and a person acts on it.

Denial worklist triage. Sorting denials by reason code, matching them to the original claim and routing each to the right person is mechanical work. The appeal itself, especially when it argues medical necessity, stays with a person.

Reconciliation between internal systems. Matching patient accounting with the general ledger, payroll with time and attendance, or charges with the charge master. Where the systems have no interface and their vendors have no plans to build one, a bot that compares data and reports discrepancies to a person is a good solution. It changes nothing, so its mistakes cost at most review time.

Remittance from the paper and PDF tail. Most remittances arrive as electronic 835 files, but some payers still send paper or PDF explanations of benefits. A bot combined with document recognition can extract them for posting, provided unmatched items go to a person rather than being forced into a match.

Provider credentialing and enrollment data entry. Re-entering the same provider data into multiple payer portals is a classic portal-only task, and the results are checked by the payer before enrollment takes effect.

Staff account provisioning and removal. A new physician needs accounts in several systems, and a departing one should lose access everywhere the same day. In organisations without central identity management, a bot that creates and disables accounts from an HR request reduces risk rather than adding it. It is one of the few cases where RPA improves security.

In each of these cases the bot works at the edge of the clinical process, not in its middle. If it is down for an hour, no one goes without care.

Where does a bot turn into technical debt?

Wherever an official interface exists and the bot goes around it. Eligibility verification is the clearest example. The 2025 CAQH Index reports that 96% of medical plans handle eligibility and benefit verification fully electronically. A bot that checks eligibility by logging into the payer portal for payers that support 270/271 transactions is not solving a problem. It is covering for a gap in the practice management system or the clearinghouse contract, and moving that gap into IT, where it will come back with every portal redesign.

The same logic applies to e-prescribing, lab orders and results, and electronic claim submission: where the standard transaction exists, the money belongs in using it properly. Outside the US the pattern repeats. In Poland, for example, e-prescriptions, e-referrals and reporting of medical events all go through the national P1 platform, and structured e-invoicing through the national KSeF system became mandatory for the largest taxpayers on 1 February 2026. A bot reading supplier PDFs, reasonable a year earlier, now serves a shrinking margin of documents. In the EU more broadly, the European Health Data Space regulation (Regulation 2025/327) entered into force in March 2025 and will require exchange of defined categories of health data in standard formats in the coming years.

For a COO the conclusion is the same everywhere: the direction is clear, and any bot built on a screen that a standard is about to replace has an expiry date.

That does not mean a bot never makes sense in these areas. It can be a bridge for a few months when the vendor has promised an integration and the process is on fire now. In that case, say so explicitly: the bot has a switch-off date, an owner and a budget for its replacement. It is the same logic we describe for the strangler fig pattern: a temporary solution is fine, as long as everyone knows from day one what will replace it and when.

What does the CMS prior authorization rule mean for bots built today?

Prior authorization is the single most common RPA pitch in US healthcare, because it is painful, measurable and largely portal-based. The regulator has chosen a different route.

In January 2024 CMS published the Interoperability and Prior Authorization Final Rule (CMS-0057-F). It applies to Medicare Advantage organisations, state Medicaid and CHIP fee-for-service programmes, Medicaid managed care plans, CHIP managed care entities and qualified health plan issuers on the federally facilitated exchanges. Since January 1, 2026, most of these payers must decide expedited requests within 72 hours and standard requests within seven calendar days, and give a specific reason for every denial. They had to post their first public prior authorization metrics by March 31, 2026. By January 1, 2027 they must offer a Prior Authorization API that tells the provider what documentation is required, accepts the request and returns the decision. CMS estimated savings of about USD 15 billion over ten years.

What does that mean for a bot submitting authorizations through those payers’ portals today? That for a significant share of its volume, it has around a year and a half to live. The CAQH data shows the change is real but uneven: in the 2025 Index, 63% of medical plans were developing electronic prior authorization FHIR APIs ahead of the 2027 deadline, while only 20% of providers had started implementation on their side. Fully electronic prior authorization among medical plans rose from 31% to 40% over two editions of the Index.

So the gap is on the provider side, and that is where the money should go: mapping documentation requirements, cleaning up order data, and working with the EHR vendor on support for the HL7 Da Vinci implementation guides that CMS recommends. A bot that keeps the old portal workflow alive does nothing to close that gap.

There is a second lesson from 2024. When the Change Healthcare ransomware attack disrupted one of the largest clearinghouses in the country, CAQH notes that providers fell back on portals and manual processes, and staff submitted claims and prior authorization documents by hand. Automation built on a single access point is only as resilient as that point, and a portal bot does not add resilience; it adds another dependency.

Why are prior authorization, coding and clinical documentation poor first candidates?

Because each fails at least one of the three questions, even though each looks best on a slide.

Prior authorization has high volume and measurable outcomes, so payback is easy to calculate. But the interface the bot would use is being replaced by a standard, and the request is rarely purely mechanical: someone has to select the right clinical documentation, judge whether it meets the payer’s criteria and respond to requests for more information. A bot can gather documents and populate fields. Deciding what to send needs knowledge a rule does not have.

Medical coding means choosing ICD-10-CM diagnoses and CPT or HCPCS procedure codes, which determine payment and drive audit exposure. It has a strong financial incentive and strong payer scrutiny. A bot that systematically codes high creates audit and repayment risk. A bot that codes low quietly reduces revenue. In both cases the error is not caught immediately but months later. This is a place for AI-assisted suggestions reviewed by a certified coder or the physician, not for a rule that picks the code.

Clinical documentation is part of care. A bot copying data between systems can place a result in the wrong patient’s chart, carry over a discontinued medication or confuse units. No administrative gate will catch that error, because administration does not read the clinical record. If data has to move, it moves through an integration with validation, with the source marked and a visible “to be reviewed” status.

None of this means those areas should stay as they are. It means they need a different tool: integration where the problem is data transport, and AI with human oversight where the problem is judgement. We describe how to design that oversight so it does not become a rubber stamp in our article on human in the loop.

What should never be handed to a rule-based bot in clinical workflows?

There is a group of tasks where rule-based automation is a bad idea regardless of volume, interface and bot quality. What they share: an error goes straight to the patient, and the cost of one mistake outweighs the savings from thousands of correct operations.

The first is medication orders and dosing. Even if a bot only moved an order from one system to another, differences in dictionaries, units and dosage forms can change the dose. This belongs in an integration with pharmacy validation, not in copied fields.

The second is critical results. A result that requires an immediate response from a clinician cannot sit in the queue of a bot that happens to be down because the lab system was updated overnight. The critical result notification path needs guaranteed availability and its own monitoring.

The third is triage and clinical eligibility. Assigning urgency, qualifying a patient for a procedure, deciding on admission. A rule can support these, for instance by flagging missing tests, but it cannot decide.

The fourth is patient identity. Merging records, resolving duplicates and matching documents to patients are tasks where errors are hard to detect and hard to undo. A bot can find merge candidates. A person merges.

This list is not distrust of technology. It reflects how the cost of error is distributed in healthcare: in administration a mistake costs time and money, in clinical work it can cost health. For leadership it is also a question of accountability, which cannot be transferred to the bot vendor, because the provider of care remains the provider.

What security and HIPAA risks come with a bot that touches patient data?

A bot working inside an EHR or patient accounting system handles protected health information, and the covered entity remains responsible for it. The HIPAA Security Rule at 45 CFR 164.312 requires unique user identification, defined as assigning a unique name or number for identifying and tracking user identity, and audit controls that record and examine activity in systems containing electronic PHI. In the EU, the GDPR treats health data as a special category (Article 9) and requires appropriate security of processing (Article 32). In practice this translates into a handful of hard requirements to write into the project before the first line of bot code, not after the first audit.

Its own service account. A bot must not run on a staff member’s login or a shared departmental account. If the audit trail shows that a billing specialist opened 3,000 patient records between midnight and 4 a.m. on a Sunday, nobody can tell automation from misuse.

Minimum necessary access. A bot that reconciles payments does not need access to the full clinical record. Permissions are granted for a specific task and reviewed along with other accounts.

Credentials in a vault. Bot passwords, tokens and certificates live in a secrets manager, not in a script or a configuration spreadsheet. This matters most for payer portal credentials that identify the organisation and its providers.

A log of the bot’s own actions. Beyond the logs of the system the bot works in, the bot needs its own record: what it did, on which data, with what result, and what it rejected. Without it, an incident cannot be reconstructed and an accounting of disclosures cannot be answered with confidence.

A named business owner. Every bot has an owner in the business function who is accountable for its rules and outputs. IT is accountable for the bot running. The process owner is accountable for it doing the right thing. Where that role is missing, bots multiply without control and nobody knows which are still needed.

Then there are the terms of use of external portals. Some payer and partner portals restrict automated access in their terms. Before a bot starts logging into someone else’s system, check that it is allowed to. All of this sits within the broader discipline of regulatory compliance, which in healthcare projects is part of scope, not an add-on.

How do you estimate a bot’s lifespan, not just its payback?

The standard RPA business case goes like this: hours saved per month times the loaded hourly cost, minus licences and maintenance, gives the payback period. In healthcare it is missing a variable that often decides the result: how long the bot will run before it has to be rebuilt or switched off.

We suggest adding a simple lifespan estimate to every decision. It is an estimate, not a formula, because it depends on factors that have to be assessed for each organisation:

  • The application’s release cycle. How often does the EHR, lab system or payer portal ship versions that change screens? Cloud applications and payer portals change more often than on-premise systems with controlled upgrades.
  • Regulatory and payer announcements. Has CMS, a state Medicaid agency or a major commercial payer announced an API for this process? If so, the bot’s life ends no later than the API go-live for that payer.
  • The organisation’s own plans. Is an EHR replacement, a cloud migration or a merger expected within two years? Each of these resets the bot to zero.
  • The exception rate. A process where 30% of cases need human handling is not automated but semi-automated, and the bot in it is an expensive sieve.

A simple decision rule follows. If the estimated lifespan is shorter than the payback period, the bot does not make sense. If it is longer but under two years, the bot is a bridge and must be planned together with the target solution. If it exceeds two years and the process passes the three questions at the start of this article, it is a good candidate.

The same logic applies to maintenance. Every update to a system the bot works on means a regression test and often a fix, so the cost of a UI-bound script grows with each interface change rather than falling over time. If AI is part of the bot, add the cost of keeping data quality up, which budgets tend to leave out. We cover that in our article on the real cost of AI.

What does the decision matrix look like: bot, integration, AI or a person?

The table below brings together typical processes from US revenue cycle and hospital back office. The assessment is directional: in a specific organisation the result depends on its systems, vendors, payer mix and plans. The “interface lifespan” column is the estimate described above, not market data.

ProcessInterface lifespanWho catches the errorClinical judgementRecommendation
Claim status checks, long-tail payers without electronic inquiryLongBiller acting on the statusNoRPA
Denial worklist triageLongBiller working the appealNoRPA (bot sorts, person appeals)
Patient accounting to general ledger reconciliationLong (internal systems)Finance at month-end closeNoRPA
Credentialing data entry into payer portalsMediumPayer enrollment reviewNoRPA
Staff account provisioning and removalMedium (until central identity management)Manager, access reviewsNoRPA as a bridge to identity management
Paper and PDF remittance extractionMedium (shrinking tail)Cash posting reconciliationNoRPA plus document recognition, unmatched to a person
Eligibility verification with payers supporting 270/271Not applicable (standard exists)—NoIntegration via PM system or clearinghouse
Prior authorization with payers covered by CMS-0057-FShort (API by 2027)Payer, after the factPartlyIntegration; AI to assemble documentation with human review
Medical coding (ICD-10-CM, CPT)—Payer audit, months laterYesAI suggestions, coder or physician decides
Medication orders, critical results, triage—Nobody before the patientYesPeople, supported by validated integration

The most important column for rows that do not end in RPA is the last one. It does not mean “do nothing”. It means the money earmarked for a bot is better spent on integration, on simplifying the process or on well-designed AI support.

How do you start an automation programme in the first 90 days?

An automation programme in healthcare should start with an inventory, not with choosing an RPA platform. The order matters, because a platform chosen first starts looking for processes to justify itself, instead of processes looking for the right tool.

Days 1–30: map processes and interfaces. List the 15 to 25 administrative processes that consume the most screen time. For each, record the systems involved, the interfaces that exist (including ones the organisation does not use because it never licensed the module or enabled the clearinghouse feature), vendor roadmaps and payer or regulatory announcements. At this stage it often turns out that some problems are solved by switching on an existing integration or by a conversation with the EHR vendor.

Days 31–60: screen with the three questions. Every process goes through the questions about interface lifespan, error detection and clinical judgement. Those that pass are ranked by volume, handling time and exception rate. For those that fail, write down the alternative: integration, process simplification, AI with oversight, or leaving it alone. While you are at it, document the process as it actually runs, not as the policy describes it, because a bot automates reality, not documentation.

Days 61–90: the first bot and the rules of the game. Choose one process with a long interface life, an independent check and no clinical judgement. Build it together with the rules every later bot will follow: service account, credential vault, action log, business owner, review date. Measure the result not only in hours but also in exceptions handed to people and in failures after updates.

Started this way, an organisation knows more after one quarter than after a year of “automating everything”: which processes really qualify, what maintenance costs and where integration matters more. The skills needed go well beyond an RPA developer. You need an analyst who understands the revenue cycle, an integration engineer who knows X12 and FHIR, a tester and someone accountable for security. We cover how to assemble a team for a digital health project in our article on healthcare digitisation.

What are the key takeaways before you decide to automate?

RPA in healthcare is neither a cure for staffing shortages nor a technology to dismiss. It is a tool with a specific job: moving and reconciling administrative data between systems that have no better way to communicate and will not get one soon. Outside that job, a bot becomes debt that grows with every system update.

Remember five things. First, before calculating payback, ask three questions: how long will the interface live, who will catch the bot’s errors, and is there clinical judgement in the process. Second, where an official interface exists or is mandated, such as standard eligibility transactions or the CMS Prior Authorization API, a bot is a symptom of an integration gap, not a solution. Third, the use cases promised most loudly, prior authorization, coding and clinical documentation, need integration or AI with human oversight, not a rule clicking through screens. Fourth, every bot gets its own service account, minimum necessary access, an action log and a business owner. Fifth, estimate a bot’s lifespan alongside its payback, and plan every bridge bot together with the solution that will replace it.

If you are preparing an automation programme or a healthcare integration and need analysts, integration engineers or testers who know the domain, see how we work with healthcare IT specialists, or book a call. Specialists start within two weeks, and if someone is not the right fit, we replace them within five business days.