RPA
Robotic Process Automation (RPA) uses software bots to mimic human keystrokes and clicks across business applications, executing repetitive, rule-based tasks like data entry, invoice posting and reconciliation. In AR and O2C, RPA was the dominant automation paradigm of the 2010s, but its brittleness and maintenance overhead are pushing finance teams toward agentic AI for the same workflows.
Robotic Process Automation (RPA) is a category of software that executes repetitive, rule-based work by imitating how a human operates a computer. A bot logs into the ERP, opens a screen, copies a value from one field, pastes it into another, clicks save, and moves to the next record. RPA does not change the underlying systems. It sits on top of them and drives the user interface the same way a clerk would, only faster and without breaks.
Finance teams adopted RPA aggressively between roughly 2015 and 2022, particularly in shared service centres handling accounts receivable, accounts payable and general ledger close work. The pitch was simple: rather than rebuild legacy ERPs or wait for vendor roadmaps, deploy bots to handle the high-volume swivel-chair tasks (moving data from email to ERP, from bank file to cash application module, from spreadsheet to reporting tool). For many organisations, RPA was the first taste of automation in finance and delivered real efficiency gains on stable, well-scoped processes.
RPA tools generally combine three techniques. The first is UI automation, where the bot reads the application's interface (button positions, field IDs, on-screen text) and issues mouse and keyboard events against it. The second is screen scraping, where the bot uses optical character recognition or DOM parsing to read values from screens that do not expose an API. The third is recorded macros, where a developer or business user demonstrates the workflow once and the platform captures the click sequence as a reusable script.
A typical bot is built as a flowchart of these steps with conditional branches: if the customer ID matches, post the payment; if not, route to an exception queue. The logic is explicit and brittle. Every path the bot needs to handle has to be coded in advance. There is no model of the world, no understanding of intent, just a sequence of UI commands that runs until it hits something unexpected.
In order-to-cash, RPA has been deployed against a familiar set of tasks. Invoice posting: bots take invoice data from an upstream system (billing platform, EDI feed, spreadsheet) and post it into the ERP's AR sub-ledger. Payment posting: bots open lockbox files or bank statements, look up the customer, and apply the cash to open invoices when the remittance matches cleanly. Exception report processing: bots run unapplied cash, short-pay or aging reports on a schedule and route the output to collectors. Customer master maintenance: bots update credit limits, tax codes or payment terms based on rules from a credit policy spreadsheet. Dispute logging: bots transcribe customer emails into the dispute module so a human analyst can pick them up.
The pattern is consistent. RPA shines on high-volume, low-variance work where the rules are explicit and the inputs are clean. It struggles the moment the data is ambiguous or the workflow forks in ways the developer did not anticipate.
Three weaknesses dominate. First, brittleness. Because bots interact through the UI, any change to that UI breaks them. An ERP patch that renames a button, a SaaS update that shifts a field down by one pixel, a browser upgrade that changes how a dropdown renders: all of these can take a bot offline. Industry research has put the average RPA bot at fifteen to twenty maintenance interventions per year, and 2025 automation surveys find that roughly 35 percent of total RPA program cost is spent on bot upkeep rather than new automation.
Second, no exception handling. When a bot encounters something outside its rule set (a remittance with a typo, a payment that covers two invoices partially, an unmapped customer), it stops and queues the work for a human. In cash application, exception rates of 20 to 40 percent are common, which means a large share of the work the bot was meant to eliminate still lands on a person.
Third, no contextual judgement. RPA cannot read a customer email and decide what it means. It cannot weigh the cost of chasing a small short pay against the relationship risk. It executes the rule it was given and nothing more.
Agentic AI is the next-generation paradigm replacing RPA for these workflows. The difference is architectural. RPA is rule-following: a developer writes the rules, the bot replays them, and anything outside the rules fails. Agentic AI is goal-driven: the operator sets an objective (apply this cash, resolve this dispute, collect this invoice) and the agent reasons about how to achieve it, using language models to interpret unstructured inputs, calling APIs rather than driving screens, and learning from outcomes.
For finance, three differences matter most. Agents handle exceptions natively because they reason about meaning rather than matching strings. Agents are API-native rather than UI-bound, so they do not break when an application changes its screens. Agents improve over time as they see more data, while RPA bots stay frozen at whatever rules were written on day one.
Most finance teams do not rip out RPA overnight. The realistic path is workflow by workflow. Start with the processes where RPA breaks most often (cash application, dispute triage, complex deduction coding) and replace those bots with agentic workflows first. Keep RPA for the truly stable, high-volume, low-variance tasks where it works and the maintenance cost is manageable. Over time, as the agentic stack handles more of the messy work, the RPA estate shrinks and the bot-sprawl problem (hundreds of brittle scripts owned by no one) becomes easier to retire. The endpoint is not zero automation. It is a finance function where the automation actually understands what it is doing.
RPA is not obsolete, but its scope is narrowing. For genuinely stable, rule-based, high-volume tasks where the source systems rarely change, RPA can still deliver value at a low cost. For anything involving unstructured inputs, exception handling or contextual judgement (which describes most modern AR and O2C work), agentic AI now outperforms RPA on both accuracy and total cost of ownership.
RPA follows rules. A developer writes a script (click here, copy this, paste there) and the bot replays it. Agentic AI pursues goals. The operator says what outcome they want (apply this payment, resolve this dispute) and the agent figures out how to get there, including handling cases the operator did not anticipate. RPA is a robot. Agentic AI is more like a junior analyst who reasons about the work.
Because bots interact through the user interface rather than through stable APIs, any change to the UI of the underlying application can break them. Industry research has found that finance RPA programmes spend around 35 percent of their total budget on bot maintenance. Every ERP patch, SaaS upgrade or workflow change creates remediation work.
Invoice posting from upstream billing systems into the ERP, payment posting when remittance data matches cleanly, scheduled exception and aging reports, customer master updates driven by credit policy, and dispute logging from email into the AR module. These are all rule-based tasks where the inputs are reasonably structured and the outputs are predictable.
Cash application is a high-exception process. Even with strong RPA, typical exception rates run between 20 and 40 percent, driven by missing or malformed remittance data, partial payments, unmapped customers and short pays. The bot handles the clean cases and stops on everything else, which means a large share of the work still lands on human analysts. Agentic AI closes that gap by reasoning about ambiguous remittance text rather than matching it literally.
Workflow by workflow, not all at once. Identify the processes where RPA breaks most often or carries the highest maintenance burden (typically cash application, dispute triage and deduction coding) and replace those first. Keep RPA running for the stable, high-volume processes where it works. Over time, as agentic workflows absorb the messy work, the RPA estate shrinks and the bot-sprawl problem becomes manageable rather than overwhelming.
