Daily Bank Reconciliation Automation for a Multi-Entity Hospitality Group

Client context

A hospitality group operating twelve legal entities with about thirty bank accounts across five banks. I delivered this as an RPA development engagement: solution design, build, a shadow-mode testing phase, and handover to the finance team.

The problem

Every morning at 8:30, two accountants started the same routine: log in to five different bank portals, download yesterday's statements for thirty accounts, export the ledger from Sage Intacct, and match the two sides line by line in Excel. On a good day it took until lunch. After a weekend, longer.

Matching wasn't the only cost. Because reconciliation ran a day or more behind, problems surfaced late. A duplicated supplier payment or a missed card settlement might sit unnoticed for a week, then take real effort to untangle. At month-end, unresolved breaks piled up exactly when the team had the least time to chase them.

The group's controller didn't want extra headcount for what is, frankly, mechanical work. They wanted their accountants investigating discrepancies, not finding them.

The automation I built

I built the reconciliation as an unattended robotic process automation on UiPath, scheduled through Orchestrator to run before business hours. Getting the statements was half the project: where a bank offered delivery over SFTP or an API, I used it — screen automation should be the last resort, not the default. Two banks offered nothing better than their web portal, so for those the robot logs in and downloads the files, with sessions registered as trusted devices to keep multi-factor authentication manageable.

The matching engine runs in tiers. First pass: exact matches on amount and reference. Second pass: fuzzy matches within a date window, which catches card settlements landing two days after the ledger entry. Third pass: one-to-many matching for batched deposits, where a single ledger entry corresponds to a dozen bank lines. Anything still unmatched lands in an exception workbook with a reason code, so an accountant starts from a diagnosis instead of a raw list.

One deliberate choice: the robot does not post journal entries. The client's auditors were comfortable with automation preparing the reconciliation but wanted a human clicking "post." We honored that — the robot marks its matches, and a person approves them in batches, which takes minutes.

• Unattended daily runs scheduled before business hours via UiPath Orchestrator
• Statement collection over SFTP and bank APIs where available; portal automation only where not
• Direct ledger extraction from Sage Intacct through its API
• Three-tier transaction matching: exact, fuzzy date-window, and one-to-many for batched deposits
• Exception workbook with reason codes — every unmatched item arrives pre-diagnosed
• Duplicate payment detection across all twelve entities
• Human approval before anything is marked reconciled — by design, not by limitation
• Full run logs and screenshots retained for audit

What made it hard

Bank portals were the ugly part. One bank changed its login flow twice during development, and MFA rules meant we couldn't simply script around it. The lasting fix was organizational rather than technical: the client's relationship manager arranged SFTP statement delivery, and that portal automation was retired three months after go-live. I'd rather delete a robot than maintain a fragile one.

The matching rules also took longer than expected — not to code, but to specify. "These two lines obviously match" turns out to encode a lot of accountant intuition. Card settlements lag by one to three days depending on the acquirer. Some suppliers reuse payment references. Batched restaurant deposits mix card types with different fee structures. We ran the robot in shadow mode for three weeks, comparing its output against the accountants' manual work, and tuned the tolerances until the false-match rate was effectively zero. Under-matching is annoying; wrong-matching is dangerous.

Results

The reconciliation went from two people's mornings to a robot's pre-dawn run plus a short human review:

• Daily reconciliation effort dropped by roughly 85% — to under an hour of reviewing exceptions
• Discrepancies now surface the next morning instead of days or weeks later
• Month-end close shortened by two days
• A duplicated supplier payment was caught in the first month — before the funds went out twice
• Auditors get a cleaner trail than the manual process ever produced: every match has a timestamp, a rule, and a log entry

Business impact

The finance team got its mornings back, and the work that remains is actual accounting — investigating genuine discrepancies rather than hunting for them. Process optimization here wasn't about speed for its own sake; it changed the team's relationship with month-end. Breaks are handled the day they appear, so close week stopped being a cleanup operation. The controller has since scoped two more finance automations on the strength of this one.

Lessons learned

Two things stayed with me from this project. First: always ask the bank before scraping the bank. Statement feeds, SFTP delivery, and open banking APIs exist, and one phone call to a relationship manager can eliminate the most fragile part of an automation. Second: shadow mode is worth every day it runs. Three weeks of comparing robot output to human output built the trust that made the team actually rely on the system — and it surfaced matching edge cases I would never have designed for from a spec.

Stack