Choose the mechanism step by step, on three tests: how often the step changes, how many items it handles, and who owns the interface. API-first is a sensible default, not a rule.
The default fails in a predictable place. A Kuwait bank's procurement cycle fell from 139 days to 57 days, a 59% reduction. Headcount stayed the same and no automation was built first (REAL, one procurement cycle). Design came first. Mechanism choice is the next decision, and it deserves the same discipline.
What do API-first and bot-first automation mean?
API-first means a step is automated by calling a published interface on the system of record. Data moves system to system, with no screen involved.
Bot-first means a step is automated by software that drives the same screens a person uses: it logs in, reads fields, clicks, and types. Teams call this RPA, or robotic process automation.
A third option is easy to forget: leave the step human. Some steps should stay manual, and some should not exist at all.
The question this post answers is the one an ops engineer faces after the design is signed off. For this step, do we call an API, run a bot, or leave a person on it? For the wider build-or-buy question, see low-code automation vs AI process engineering. For the category itself, see RPA in banking process engineering and AI process automation vs RPA in banking.
Why "API beats bot, always" costs real money
The industry default is clean and wrong often enough to matter. APIs are faster, more stable, and easier to test. That is true when someone owns the interface.
Take your last ten automations and ask who owns each interface. If the answer is "the vendor", you did not choose API-first. You chose dependency-first.
An unowned API is a dependency you cannot see, version, or monitor. The contract changes on a Tuesday. A field becomes optional, a code list gains a value, a rate limit tightens. Nobody was told, so the integration keeps running and keeps returning plausible, wrong data.
A bot fails the other way. The screen changes, the bot stops, and an operator sees the queue stop moving. It is visible, reversible, and cheap to retire.
A bot is a temporary scaffold. An API is a permanent promise. Price them differently.
Under MAS and Bank Negara Malaysia supervision, a dependency on a third-party interface is also a third-party risk question, not only an engineering one. Silent change is the part risk teams like least.
Gate: only automate what survived Eliminate and Simplify
Before any mechanism question, the step has to earn its place. In the E-S-S-A-M framework (Eliminate, Simplify and Standardise, Automate, Migrate), Automate is the fourth action, on purpose.
Automating a step that should have been eliminated gives you a fast, monitored, expensive way to do something unnecessary. In the Kuwait case, the 82 days of work retired came from Eliminate and Simplify alone.
In the 7-step AI Lean Cycle (Baseline, Map, Analyse waste, Optimise, Document, Deploy, Improve), mechanism choice sits after Optimise. It belongs in the Document step, so the next person knows why a step runs the way it does.
Three entry conditions apply before you classify anything:
- The step survived Eliminate and Simplify.
- The step has a system of record to read from or write to. "We'll API it" is a category error when the data lives in an inbox and a spreadsheet.
- Someone will own whatever you build.
Fail the second and you have a process problem, not an automation problem. Fail the third and the next section tells you what to do.
The volatility x volume x ownership matrix
The matrix scores each step on three axes. The thresholds below are working defaults (EST). Set your own from your own change logs.
- Volatility: how often the interface, screen, or rule changes. Low means up to two changes a year. High means three or more.
- Volume: items per working day. Low means under 100. High means over 1,000. In between, let the exception cost in the next section decide.
- Ownership: who can tell you before the interface changes. Owned means an internal team, or a contract with change notice and a named contact. Unowned means a vendor or portal that changes without telling you.
| Volatility | Volume | Ownership | Mechanism | Why |
|---|---|---|---|---|
| Low | High | Owned | API | Stable, heavy, and someone watches the contract |
| Low | High | Unowned | Get ownership first, then API | A named owner or change-notice clause is the real deliverable |
| High | High | Owned | API with versioned contract | The owner absorbs the volatility; you pin a version |
| High | High | Unowned | Process fix | Bots drown the team in exceptions, and an API breaks silently |
| High | Low | Unowned | Bot, with a retirement plan | Visible, disposable, cheap to switch off |
| High | Low | Owned | Bot until the owner ships a stable version | Do not build a permanent integration against a moving target |
| Low | Low | Owned | API if one already exists, else leave human | Building a new integration for 40 items a day rarely pays |
| Low | Low | Unowned | Bot or human | Small, stable, and low risk if it stops |
Two rules sit over the table. First, a bot needs an owner too: a named person who owns its monitoring and its retirement date. Second, if neither the interface nor the bot will have an owner, the step is not an automation candidate. It is a process fix.
Three worked banking steps
These are constructed examples. They do not describe any client.
Step 1: reference-rate load into a pricing workbook. The rate comes from an internal treasury system that exposes a service. It changes once a year at most, runs several thousand times a day, and the treasury technology team publishes release notes. Low volatility, high volume, owned. Mechanism: API. A bot here would add a screen to break.
Step 2: submission to a government e-filing portal. Picture a portal that offers a web form and nothing else. It handles about 15 filings a day, and the form has changed three times in a year without notice. High volatility, low volume, unowned. Mechanism: bot, with a retirement plan. No API exists to prefer. If the portal publishes one, the bot gets retired.
Step 3: credit data check on loan applications. Picture a vendor-run data feed, used about 1,200 times a day. It is stable, but changes arrive by email to a shared mailbox that nobody reads. Low volatility, high volume, unowned. Mechanism: get ownership first. Name an owner, or negotiate change notice, and then build the API. Until then, the integration works only because nothing has changed yet.
Step 3 is the instructive one. The engineering is easy. The ownership gap is the actual defect, and a better integration does not fix it.
What each choice costs over three years
Every figure below is an estimate (EST). The assumptions are printed so you can replace them with your own.
| Assumption (EST) | Value |
|---|---|
| Engineer day rate, fully loaded | S$900 |
| Operations staff hour | S$40 |
| Horizon | 3 years, 250 working days a year |
| Bot build | 10 to 20 engineer days |
| Bot upkeep | 3 to 5 breakages a year at 1 to 2 days each, plus 3 monitoring days a year |
| Bot exception rate | 2 to 5% of runs, 10 minutes each |
| API build | 20 to 40 engineer days (authentication, error handling, testing, security review) |
| API upkeep, owned | 4 days a year of contract and version review, 2 to 4 days of change work, 3 monitoring days |
| API upkeep, unowned | No contract review. Same change work and monitoring. 1 to 2 silent breaks a year at 3 to 6 days each |
| API exception rate | 0.2 to 0.5% of runs, 10 minutes each |
| Volumes compared | 40 items a day (about 10,000 runs a year) and 4,000 items a day (about 1 million runs a year) |
| Three-year cost (EST) | 40 items a day | 4,000 items a day |
|---|---|---|
| Bot | S$29k to S$63k | S$425k to S$1.05M |
| API, owned interface | S$43k to S$67k | S$82k to S$166k |
| API, unowned interface | S$40k to S$88k | S$80k to S$187k |
The figures cover engineering time and exception handling only. They exclude licences, infrastructure, and the cost of an outage reaching a customer.
Three readings follow.
- At low volume, the bot is competitive. Its range starts lower and the ranges overlap. Volatility and the retirement plan decide, not architecture taste.
- At high volume, exceptions dominate. A 2 to 5% bot exception rate over a million runs a year swamps the build cost. This is where an owned API pays for itself.
- The unowned API costs variance, not mean. Its midpoint is about S$9k above the owned API at low volume. Its spread is wider and its worst case is the highest, because the failures arrive unannounced. No vendor page prices that.
Step-classification worksheet
Run every step in the build queue through this worksheet. One row per step. Fill the columns left to right and stop at the first failure.
| Step | System of record | Interface owner | Volume per day | Volatility per year | Mechanism |
|---|---|---|---|---|---|
| Reference-rate load | Treasury system | Treasury technology | 3,000+ | Under 1 | API |
| E-filing submission | Portal (web form only) | None | About 15 | 3 | Bot + retirement plan |
| Credit data check | Vendor feed | None named | About 1,200 | Under 1 | Hold: assign owner, then API |
How to use it:
- Step. Write the step as it survived Eliminate and Simplify, not as it was drawn in the baseline.
- System of record. If there is none, stop. The step is not an automation candidate until the data lives somewhere callable.
- Interface owner. Write a name or a team. "The vendor" does not count.
- Volume. Use the baseline count per working day.
- Volatility. Count changes in the last 12 months from release notes, change tickets, or the bot's own break log.
- Mechanism. Read the row off the matrix. If the row says process fix, send it back to the design stage.
The retirement plan every bot ships with
A bot without an exit is the debt that never gets reviewed. Before a bot goes live, write down:
- Trigger: the event that retires it, such as "the owner publishes a stable service for this data".
- Owner: the named person who watches for that trigger.
- Review date: a calendar date, set at most two quarters out.
- Break log: every failure, with date and cause, so volatility is measured rather than remembered.
- Rollback: the manual procedure, kept current, that takes over if the bot stops.
- Evidence: the cycle time and exception count to compare against the baseline in the before/after audit view.
The last item applies to APIs too. Whichever mechanism you pick, it should leave evidence you can set against the baseline. An integration you cannot show to an auditor has not finished the job.
The 2am test: who notices when it breaks?
The bot nobody monitors and the API nobody owns cost the same at 2am. Both fail, and nobody on shift knows why.
Apply the test to every row of the worksheet before build. Ask three questions:
- Who gets alerted, and how fast? A bot should alert on a stalled queue. An API should alert on schema drift and on a sudden change in the share of empty fields, not only on HTTP errors.
- Who can fix it? A named engineer needs access to the bot's logs or the interface's change history.
- What does the operator do meanwhile? The manual fallback must be a current work instruction, delivered where the team already works. In Singapore and Malaysia, that is usually WhatsApp.
The 7-step cycle closes the loop. In the Improve step, re-run the worksheet each cycle. Volatility counts change, owners move on, and an API that did not exist last quarter may exist now. Every bot's review date is a prompt to ask whether it can retire.
A disposable bot, done right
Consider a team that automates a 40-item-a-day approval check with a bot. The screen changes twice in the first quarter, and each time the bot stops and an operator sees it within the hour. Two quarters later the owning team ships a stable service.
The bot is retired in an afternoon. Because it shipped with a trigger, an owner, and a manual fallback, nobody had to remember it existed. The bot was the right first call because it was disposable. (Constructed example, not a client outcome.)
Frequently asked questions
When should I use RPA instead of an API? Use a bot when the step is volatile, the volume is low, and no usable interface exists or you do not own one. Give it a retirement plan.
Is API automation always more reliable than RPA? No. An owned, versioned API is more reliable. An unowned API can fail silently, which is harder to detect than a bot that visibly stops.
What if a step has no system of record? Then there is nothing to call and nothing for a bot to read reliably. Fix the process and give the data a home first.
How do I decide for steps in the middle on volume? Estimate the exception cost: runs per year x exception rate x minutes per exception x hourly rate. If it exceeds the cost of an owned API, build the API.
Pick the mechanism last
Choosing a mechanism is the final design decision before build. The sequence is Eliminate, Simplify, classify, and only then Automate. Steps that fail the ownership test go back to the design stage, where they belong.
ESSAM captures a process in a single session, classifies every step with E-S-S-A-M, and deploys living work instructions over WhatsApp. The features page covers capture and the before/after audit view. The AI process engineer hub explains the discipline behind them.
Classify your next automation step with ESSAM: apac.essam.ai
