Capability
The re-keying, the copy-paste, the spreadsheet that reconciles what neither system knows. We map the process as it actually runs, automate the routine path, and route everything that needs judgement to a person.
From $4,500 · 3–5 weeks · fixed scope, agreed in writing
What your team gets
Not a strategy deck. A running system, the permissions around it, and the code in your repository.
What we build
These are the ones that pay back quickest, because they are high-volume, rule-shaped, and currently done by a person who would rather be doing something else.
Documents arriving by email, portal or EDI, turned into structured records in the system that needs them, with anything ambiguous held for review.
Supplier invoices read into the accounting system, low-confidence lines queued.
Two systems compared continuously rather than at month end, with only the disagreements surfaced.
Stock against accounts, raising the six lines that differ instead of the six thousand that do not.
Replacing the nightly CSV with a continuous, idempotent sync that knows what it already wrote.
Storefront orders into the ERP, with mismatched SKUs queued rather than skipped.
Quotes, contracts and reports assembled from live data on a template your team controls.
A dealer quote built from current pricing, ready to send in one step.
Requests routed by rule to the right approver, chased automatically, and recorded when they are decided.
Purchase requests above a threshold routed, escalated after two days.
A rule run on a schedule that raises a case only when something has actually gone wrong.
Negative stock, aged invoices or a failed nightly job, caught the same day.
How we build it
Automations do not usually fail on the happy path. They fail on the duplicate, the partial run, the record someone edited mid-process, and the exception nobody defined. These five decisions are what separate an automation that runs for years from one quietly switched off after a bad week.
We watch the work as it happens rather than reading the SOP. The gap between the two is where every unhandled case lives, and it is always larger than anyone expects.
Before automating anything we agree what "not routine" means and who decides. An automation without a defined exception path silently drops the hard cases, which is worse than not automating at all.
Steps are written so running one twice produces the same result as running it once. Retries then become safe, and a partial failure stops being a data-integrity incident.
Durable queues with bounded retries and dead-letter handling. Failures are visible within minutes, not discovered at month end.
Volume, exception rate, time saved and failure rate, from day one. If the exception rate climbs, the rules need revisiting — and you will know before anybody complains.
Deterministic rules handle anything that can be expressed as a rule: they are cheaper, faster and auditable. AI earns its place on the messy edges — reading a document with no fixed layout, classifying a free-text note, matching records that are almost the same. Most good automations are mostly rules with a model at two or three points, and we will tell you when a model is being used for something an if-statement should do.
The exception queue is the part clients underrate and the part that decides adoption. It shows the case, what the automation concluded, and what it was unsure about — then records the human decision. Those decisions are the training data for the next iteration, so the exception rate falls over time rather than sitting where it started.
Before the build we record how long the process takes now and how often it goes wrong. After, we report the same two numbers alongside the exception rate. A process that used to take three people two days should be able to show that; if it cannot, the automation did not work and we say so.
Where it lands
Order entry between storefront and ERP, with mismatches queued instead of silently skipped.
Replenishment triggered by rule, delivery confirmations matched to their purchase orders automatically.
Continuous stock-to-accounts reconciliation, surfacing only the lines that disagree.
Exception handling on payments and statements, with every decision attributable.
Renewals, reminders and certificate issue running on a schedule instead of through the office inbox.
Onboarding paperwork routed, chased and filed without anyone tracking it in a spreadsheet.
Technology
We pick the boring option unless there is a reason not to — the framework is the part most likely to be abandoned before your system is.
How the engagement runs
Every phase ends in a named deliverable. You can stop after any of them and keep what has been built.
Which process, how often it runs, and who currently does it. We say whether it is worth automating and roughly what it would save.
We watch the work as it actually happens, count the volume, and agree what counts as an exception and who owns it.
The happy path automated end to end, idempotent, with retries and the exception queue wired up from the start rather than bolted on.
The automation runs alongside the manual process on live data, so disagreements surface before anyone depends on it.
Switch on, with monitoring, alerts and a runbook for whoever operates it, plus the measured before-and-after.
Why Devs Core
The SOP and the actual work always differ. Automating the SOP produces something that breaks on its first real week.
Most automations fail because nobody decided what happens to the hard cases. We agree that before writing the easy path.
Steps are safe to retry. A partial failure is an inconvenience rather than a reconciliation exercise.
We do not put a model in the middle of something an if-statement should do. It costs more, runs slower, and is harder to audit.
The automation proves itself against the manual process on live data before anybody relies on it.
Baseline hours before, the same measure after. If the saving is not there, you hear it from us first.
Questions
Business process automation is replacing the manual steps in a repeatable business process with software that performs them — extracting data, applying rules, moving records between systems and routing anything unusual to a person. Modern automation mixes deterministic rules for the predictable majority with AI for the messy parts, such as reading documents with no fixed layout.
Traditional RPA drives the user interface: it clicks and types like a person, which works when there is no API but breaks whenever a screen changes. We prefer APIs and direct system access, and use UI automation only where no other route exists. The result is far less brittle and far cheaper to maintain.
High-volume, rule-shaped work with a clear trigger and a measurable cost: order and invoice entry, reconciliation between two systems, data sync, document generation, approval routing and scheduled checks. A process that runs a hundred times a month and takes ten minutes each time is a better first candidate than one that is complex but rare.
They go to an exception queue with the full record, what the automation concluded, and what it was unsure about. A person decides, the decision is recorded against their name, and those decisions inform the next iteration — so the exception rate falls over time instead of staying where it started. Nothing is dropped silently.
Process automation starts at $4,500 for a fixed scope over three to five weeks, agreed in writing before work begins. The scope is driven by how many systems the process touches and whether they have usable APIs, which is what the readiness audit establishes.
We record how long the process takes and how often it goes wrong before we build, then report the same measures afterwards alongside the exception rate. The automation also runs in parallel with the manual process before cut-over, so any disagreement surfaces before anyone depends on it.
There is usually another route: a database we can read, a file exchange, an email inbox, or a vendor module. Where none exists, UI automation with Playwright is the fallback, with the maintenance cost of that choice stated plainly up front rather than discovered later.
In our experience it removes the part of a role nobody wanted — the re-keying, the chasing, the comparing of two screens — and the person moves to the exception queue, where judgement is actually needed. We will not pretend otherwise if a client’s intention is headcount reduction, but that is not how these projects have gone.
Thirty minutes, no preparation, no deck. You describe what keeps going wrong and we tell you whether AI is the answer — including when it is not.
Prefer email? contact@devs-core.com