Business Process Automation Use Cases: 9 Examples With Break-Even Math

The business process automation use cases worth building are the ones where you know exactly what breaks them, and employee offboarding shows why. In Microsoft 365, blocking a leaver's sign-in can take up to 24 hours to take effect. In apps without continuous access evaluation, an access token already issued keeps working until it expires, 60 to 90 minutes by default. And converting their mailbox to a shared mailbox leaves the old username and password working on it unless someone resets the password. An automation that only "disables the account" misses all three.

Below are nine use cases, each with its trigger, the data it needs, the exception that breaks it, the vendor detail that decides the design, and an illustrative break-even volume below which it isn't worth building. Invoice matching, duplicate invoices, bank details, timesheets and filing are in our back office automation examples. Vendor behavior and licensing are as of September 2026.

1. Quote generation

Trigger: an opportunity reaches the quoting stage, or a customer submits a request for a quote.

Data it needs: the price list version, contract prices and volume breaks, configuration rules, the discount authority matrix, tax treatment for the ship-to address, currency and exchange-rate date, lead time and validity period.

The exception that breaks it: the non-catalog item an engineer or buyer has to price, and the discount above the salesperson's authority.

Lock the price at the moment the quote is sent

In Dynamics 365 Sales, a draft quote's prices are recalculated from the current price list whenever someone opens or edits it. Only an activated quote has its total locked (Microsoft Learn). A PDF emailed from a draft can stop matching the record after the next price update. Have the automation activate or snapshot the quote in the same step that sends it, and turn any later change into a revision rather than an edit.

Conversion has its own trap. In Business Central, Make Order removes the sales quote from the database and creates an order that carries the quote number (Microsoft Learn). Set Archive Quotes on the Sales & Receivables Setup page to Always, so a copy is archived automatically (document archiving). Without it, nobody can later compare what was quoted with what was ordered.

Route approvals on margin, not on discount

Our default is to route on margin after discount, checked against a floor for each product group, because a 15% discount on a low-margin item can sell below cost while 25% off a high-margin service is fine. At or above target, the quote goes out. Between floor and target, the sales manager approves. Below the floor, on any non-catalog line, or with non-standard payment terms, finance approves with the cost build-up attached.

Threshold (illustrative): 30 minutes saved per quote; a quarter still need a person, at 10 extra minutes each; 4% of manual quotes lose $500 of margin to a pricing error, and the automation prevents three-quarters of those. Each quote is worth $30, against $1,800 a month (a $36,000 build over 24 months plus $300 to run), so the break-even is 60 quotes a month. Below that, a CRM quote template that looks up the price list, with an approval rule on margin, does most of the job.

2. Customer onboarding and screening checks

Trigger: a signed order form or credit application, or the first order from a new account.

Data it needs: the registered legal name and number (not the trading name), tax ID, addresses, the directors or owners your checks cover, the screening result with the list and date used, the credit decision, limit and terms, and any tax-exemption certificate.

The exception that breaks it: a possible sanctions match on a common name, which someone has to clear with evidence.

Hold the account until the checks pass

Create the customer on hold and let the automation release it when the last check passes. The hold can't be the credit limit, which in Business Central only warns. Use the customer's Blocked field set to Ship, which stops new orders and shipments but not payments (Microsoft Learn). Our ERP vs CRM guide compares what limits and holds stop in Business Central, NetSuite and Odoo.

Screening is a scored match, and it repeats

Take Moov Watchman, an open-source screening engine. It can load the US (OFAC), EU, UK and UN sanctions lists among others, refreshes them every 12 hours by default and scores each candidate from 0 to 1. Its README treats the cutoff, minMatch, as policy: 0.80 for screening and about 0.59 for high recall, which sends far more candidates to a person (Watchman on GitHub). Have whoever owns compliance sign off that number, and re-screen existing customers when a list updates.

Watchman doesn't store searches, and its README says your application must keep the screening log. Ask any screening vendor whether theirs does. For every candidate a person clears, record the list and its version date, the cutoff and score, the identifiers compared (registration number, country, date of birth for individuals), the decision, the reviewer and the date.

Threshold (illustrative): 40 minutes saved per account; 30% need a person, at 15 extra minutes; 1% of manual onboardings miss something costing $2,000, such as wrong terms or an unscreened owner, 80% prevented. Each account is worth $33.63, against $1,650 a month ($30,000 build plus $400 for screening data), so the break-even is about 49 new accounts a month. Below that, use a required-fields checklist and manual searches in a screening tool, but still schedule the re-screen of existing customers.

3. Order entry from customer emails

Trigger: a purchase order arrives in a shared orders mailbox, as a PDF or in the email body.

Data it needs: the sender mapped to a customer account, the customer's PO number, their part numbers mapped to yours with units of measure, the contract or quoted price, the requested date and the ship-to address.

The exception that breaks it: the revised purchase order: same PO number, one line changed.

Map the customer's part numbers, units included

Extraction can read a line perfectly and still order the wrong thing: "7731-B, 4 CS" means nothing until 7731-B maps to your item and CS to a case of 12. Business Central's Item References store a customer's or supplier's number for an item together with a unit of measure and variant, and copy both onto the document line when the reference is used (Microsoft Learn). Fill it from the last year of orders before automating, and treat an unmapped part number as an exception, never a guess.

Key every order on customer plus PO number

Before creating an order, look up the PO number for that customer. If it exists, the email is a change: compare it line by line and send the differences to a person. Store the PO number in the ERP's customer-reference field (External Document No. in Business Central), and don't count on the ERP to catch a repeat: Business Central doesn't check these numbers for duplicates (Microsoft Learn).

Acknowledge what you understood

Send the customer your reading of the order, not just "received". The Peppol ordering standard defines four header responses that work as a template for email orders too: AB, received but not yet processed; AP, accepted as sent; CA, accepted with changes, with every line included; and RE, rejected (OpenPeppol order response codes). A CA-style reply listing the price, quantity or date you changed lets the customer catch a misread before anything ships. If your order system has no API for creating orders, our comparison of workflow automation and RPA covers the options.

Threshold (illustrative): 8 minutes saved per order; 20% need a person, at 5 extra minutes; 2% of manual orders have a $150 error, 70% prevented. Each order is worth $6.15, against $2,067 a month ($40,000 build plus $400 for extraction and hosting), so the break-even is about 336 orders a month, roughly 16 per working day. Exceptions move this one a lot: at 40% the break-even rises to about 490. Below it, give your largest customers a web order form and key the rest with the item reference table.

4. Service scheduling

Trigger: a service request, or a preventive maintenance visit falling due by date or meter reading.

Data it needs: location, a duration per job type, the required skill or certification, the customer's time window, parts availability, technician calendars and start points, and travel times.

The exception that breaks it: the job that overruns, so the rest of the day has to be re-planned mid-morning.

Four design choices in Google's Route Optimization API (field definitions) are worth copying into any scheduler you build or buy:

Every job is mandatory unless you say otherwise. A shipment (Google's word for a job) without a penalty cost is treated as having an infinite one, so it must be completed. Give lower-priority jobs a penalty and the solver may skip them. Skipped jobs come back in a list with reason codes such as CANNOT_BE_PERFORMED_WITHIN_VEHICLE_TIME_WINDOWS. That list is your dispatcher's exception queue.
Hard and soft time windows are different things. A hard window can't be broken. A soft start or end adds a cost per hour for arriving early or late. Promise customers the hard window and use soft windows for preferences.
Skills are an allow-list. The allowed_vehicle_indices field limits a job to the vehicles, meaning technicians, allowed to do it. Model certifications that way.
Re-planning must not move confirmed visits. An injected solution constraint freezes the parts of routes already completed or promised, so a mid-morning re-plan only moves what is still movable.

Threshold (illustrative): 12 dispatcher minutes saved per job; 15% need a person, at 10 extra minutes; 3% of jobs need a $180 repeat visit because of a wrong skill or missed window, 60% prevented. Each job is worth $9.77, against $2,375 a month ($45,000 build plus $500 to run), so the break-even is about 243 jobs a month. If routes are long, add the drive minutes saved per job. Below the threshold, a shared calendar with fixed durations per job type and a skills matrix will do.

5. Returns and RMAs

Trigger: a return request through a portal, by email or by phone.

Data it needs: the original invoice line, serial or lot numbers, delivery date, the applicable return window or warranty, a reason code, condition on receipt, refund method and restocking-fee rule.

The exception that breaks it: what arrives doesn't match what was authorized: another serial number, quantity or condition.

Link every return line to the line it reverses

In Business Central, Get Posted Document Lines to Reverse copies lines from the original shipment or invoice, fills in Appl.-from Item Entry and always reverses the exact cost of the original sale. Copy from Document reverses the exact cost only if Exact Cost Reversing Mandatory is selected in Sales & Receivables Setup (Microsoft Learn). An automation that builds return orders from scratch loses that link, so it should create them from the posted document.

The same page documents a trap worth testing in any system: the Show Reversible Lines Only filter hides quantities already returned, but selecting all lines with Ctrl+A ignores it and copies lines already reversed. So before authorizing, total the quantity already returned against each original line across earlier RMAs, and refuse anything above the quantity shipped.

Authorize on request, credit on inspection

Our default: the RMA number is issued on request and is the key the warehouse scans at receipt, and the credit is created only once receipt and inspection are recorded. In Business Central, each line carries a Return Reason Code, and a restocking fee goes on as an item charge line rather than hiding in a smaller refund.

Threshold (illustrative): 20 minutes saved per return; 30% need a person, at 10 extra minutes; 5% of manual refunds are wrong (issued before receipt, over-refunded, fee missed) at $60 each, 80% prevented. Each return is worth $10.65, against $1,242 a month ($25,000 build plus $200 to run), so the break-even is about 117 returns a month. At half that volume, 27% of refunds would have to be wrong to justify it. Below it, use an RMA form, create each return from the posted invoice, and have a person issue credits.

6. Contract and subscription renewals

Trigger: a date counted back from the notice deadline, not the end date.

Data it needs: the start date, initial and renewal terms, the notice period and how notice must be given (in writing, to which address), the price escalator, the owner, and current usage or spend.

The exception that breaks it: the contract whose renewal terms were changed in an amendment or order form rather than in the master agreement.

Compute the deadline, then remind from it

One row per contract, with the start date in B2, the term in months in C2, the notice period in days in D2 and a named range called Holidays:

E2  End of term       =EDATE(B2,C2)-1
F2  Notice deadline   =WORKDAY(E2-D2+1,-1,Holidays)
G2  First reminder    =WORKDAY(F2,-40,Holidays)
H2  Final reminder    =WORKDAY(F2,-10,Holidays)

F2 moves a deadline that falls on a weekend or holiday back to the working day before it. The 40 and 10 working days are illustrative lead times. If notice must be received rather than sent, subtract the delivery time too.

Know the vendor's own window

Microsoft 365 business subscriptions paid by card or billing profile renew automatically by default. On a Microsoft Customer Agreement (MCA) billing account, as of September 2026, you can cancel for a prorated refund, or remove licenses, only within seven days of buying or renewing. After that, turning off recurring billing just lets the term run out, and it cancels any scheduled changes (cancel a subscription, recurring billing, buy or remove licenses). So on MCA, next year's seat count is settled at renewal, and the reminder must fire early enough to count the seats in use. Accounts on the Microsoft Online Subscription Agreement (MOSA) get a prorated credit or refund whenever they cancel, so check your account type first.

Threshold (illustrative): 20 minutes saved per renewal; 20% need a person, at 10 extra minutes; 5% of renewals are missed or late at $3,000 each (an unwanted year of a subscription, or a lapsed customer contract), 90% prevented. Each renewal is worth $145.50, against $600 a month ($12,000 build plus $100 to run), so the break-even is about four renewals a month, 50 a year. Below that, the sheet above with calendar reminders is the automation.

7. Employee onboarding and offboarding

Trigger: the hire or leave date and time in the HR system, not an email from a manager.

Data it needs: the HR employee ID, manager, role and department (which decide the access bundle), every system with the person's account ID in it, devices, licenses, and what they own: mailboxes, files, automations, API keys and portal logins.

The exception that breaks it: the account outside single sign-on, such as a portal with its own password, and the contractor who isn't in the HR system.

The leaver sequence in Microsoft 365, in order

Reset the password, then block sign-in and end sessions. The reset comes first because Microsoft's offboarding guide warns that blocking sign-in can take up to 24 hours, and says a password reset stops sign-in at once (Microsoft Learn). Then, in the Microsoft Entra admin center, go to Entra ID, Users, All users, select the user, clear Account enabled under Account status, save, and select Revoke sessions. As a script, run Update-MgUser -UserId $id -AccountEnabled:$false followed by Revoke-MgUserSignInSession -UserId $id (Microsoft Learn).
Remove access in every application. Revoking stops new tokens, but unless an app supports continuous access evaluation, an issued access token works until it expires, 60 to 90 minutes by default (token lifetimes). Entra can't revoke a session an application issued itself. Deprovision in each app: Entra's app provisioning typically runs every 20 to 40 minutes, and apps it doesn't reach need a task with a named owner.
Convert the mailbox before touching the license. The convert option only appears while a license is assigned, and a shared mailbox needs no license below 50 GB. The reset in step 1 matters here too: without it, the old username and password keep working on the shared mailbox. Don't delete the account, because it anchors the mailbox (Microsoft Learn).
Remove the license last. Remove any holds first. Once the license is removed, the user's data is kept for 30 days and then permanently deleted, except documents stored in SharePoint (Microsoft Learn). An unassigned license stays on the subscription, and on the bill, until the license count is reduced, which ties offboarding to the renewal window in use case 6.
Reassign what they owned. A Power Automate flow whose owner leaves is downgraded and turned off after 14 days unless someone acts. Change the owner of a flow that sits in a solution, have a co-owner add one that doesn't to a solution first, or assign the flow a Process license (licensing FAQ).

If you automate it with Lifecycle Workflows

Microsoft Entra Lifecycle Workflows run joiner and leaver tasks from HR dates and need a Microsoft Entra ID Governance or Microsoft Entra Suite license (Microsoft Learn). Three documented details decide whether they work (Microsoft Learn): a new workflow isn't scheduled until someone turns scheduling on; scheduled workflows are evaluated every three hours by default; and a date HR records late is still processed only if the setup is completed within three days of the intended time. A leave date typed in a week late is never picked up by the schedule, so alert on leave dates entered in the past, and use Run on demand for immediate terminations.

Threshold (illustrative): 90 IT minutes saved per joiner or leaver; 20% need a person, at 15 extra minutes; 10% of manual leavers keep an active account or paid license, costing $500, 80% prevented. Each person is worth $91.75, against $983 a month ($20,000 build plus $150 to run), so the break-even is about 11 joiners and leavers a month. Below that, a checklist ticket per leaver listing every system is enough, as long as it follows the order above.

8. Purchase requests

Trigger: a request submitted before anyone commits the spend.

Data it needs: supplier, item or service, amount including tax and freight, annual value for subscriptions, cost center and GL account, remaining budget, approval limits, and any existing contract with the supplier.

The exception that breaks it: the request split to stay under an approval limit, and the after-the-fact request for an invoice that has already arrived.

Check how the approval chain treats limits

In Business Central, each approver's limits are set in local currency on the Approval User Setup page (approval users), but the workflow's Approver Limit Type decides whether those limits count (approval workflows). Approver Chain asks every approver up the line, to and including the first with a high enough limit. Direct Approver asks only the requester's immediate approver, regardless of that approver's limit. A workflow set to Direct Approver sends a $40,000 request to a manager with a $5,000 limit, and their approval completes it.

Catch split requests

Approve on annual value, not the first invoice: a $900-a-month subscription is a $10,800 commitment. Then run a weekly check for splits. This query, in PostgreSQL syntax with an illustrative lowest limit of 5,000, finds requesters who sent the same supplier several requests under the limit that together reach it:

SELECT requester_id, supplier_id,
       COUNT(*)        AS requests,
       SUM(amount)     AS total,
       MIN(created_at) AS first_request,
       MAX(created_at) AS last_request
FROM purchase_requests
WHERE created_at >= now() - interval '14 days'
  AND amount < 5000
GROUP BY requester_id, supplier_id
HAVING COUNT(*) > 1 AND SUM(amount) >= 5000
ORDER BY total DESC;

Count after-the-fact requests per requester each month too. Our rule of thumb: a steady stream from one requester means their buying happens outside the process, and approvers are signing off spend already committed.

Threshold (illustrative): 15 minutes saved per request; 20% need a person, at 5 extra minutes; 3% of manual requests lead to a $200 out-of-policy or miscoded purchase, 60% prevented. Each request is worth $11.85, against $725 a month ($15,000 to configure and connect the ERP's own approvals, plus $100 to run), so the break-even is about 61 requests a month. Below that, use your ERP's approval workflow as it comes and run the split query monthly.

9. Compliance evidence collection

Trigger: the control's own schedule, such as each quarter's access review, each month's backup restore test or each leaver, not the audit date.

Data it needs: the control ID, the population (every leaver in the period, from HR), the timestamped evidence file, who performed and reviewed the check, the result, and exceptions with their remediation.

The exception that breaks it: evidence that expired before anyone asked, because the system keeps logs for less time than the audit period covers.

Retention sets the collection schedule

Default log retention that sets how often evidence must be collected (as of September 2026)
System and log	Default retention	What to do
Microsoft Entra ID sign-in and audit logs, Free	7 days	Upgrading doesn't bring back data that has already expired (Microsoft Learn)
Microsoft Entra ID sign-in and audit logs, P1 or P2	30 days	Archive continuously: Entra ID, Monitoring & health, Diagnostic settings, Archive to a storage account, as at least a Security Administrator (Microsoft Learn)
AWS CloudTrail Event history	90 days of management events, per Region	Create a multi-Region trail to keep events longer. Event history never shows data events, such as S3 object reads (AWS documentation)

A quarterly control tested against a 30-day log needs a monthly export or a continuous archive. Microsoft has deprecated the retention option inside diagnostic settings, so set how long archives are kept with Azure Storage lifecycle management.

One record per control run

An illustrative record for a quarterly leaver control:

control:      Leaver access removed within 1 working day
period:       2026-07-01 to 2026-09-30
population:   47 leavers, HR export hr-leavers-2026Q3.csv (SHA-256 recorded)
test:         each leaver's Entra ID account disabled by the working day after the leave date
evidence:     entra-audit-2026-07.csv, -08.csv, -09.csv, archived monthly by svc-evidence
result:       46 passed, 1 exception (employee 1043, disabled 3 days late)
remediation:  ticket OPS-2291, closed 2026-10-03
reviewed by:  finance controller, 2026-10-06

Take the population from HR, not from the system being tested. A directory only lists accounts it knows about, so a leaver whose account was never linked to their HR record never shows up as a failure, and that is the gap the control exists to find.

Threshold (illustrative): 30 minutes saved per evidence item; 10% need a person, at 20 extra minutes; 5% of manually collected items are missing when requested, costing $1,500 in retesting and follow-up, 90% prevented. Each item is worth $86.25, against $900 a month ($18,000 build plus $150 to run), so the break-even is about ten items a month, around 125 a year. Below that, a calendar of export tasks with a named owner per control does the job.

Run the break-even on your own process

Every threshold above uses this arithmetic, with a loaded staff cost of $45 an hour and the build written off over 24 months. Put your own inputs in column B of a sheet; the currency doesn't matter.

B2   t  minutes saved on a case that goes straight through
B3   x  share of cases that still need a person (0.25 = 25%)
B4   a  extra minutes a person spends on each of those cases
B5   H  loaded hourly cost
B6   e  share of manual cases with an error that costs money
B7   p  share of those errors the automation prevents
B8   C  average cost of one error
B9      build cost
B10     months to write the build off
B11     running cost per month
B12     your volume per month

B14  Value per case      =(1-B3)*B2*B5/60-B3*B4*B5/60+B6*B7*B8
B15  Monthly cost        =B9/B10+B11
B16  Break-even volume   =B15/B14
B17  Error rate needed at your volume
                         =(B15/B12-((1-B3)*B2*B5/60-B3*B4*B5/60))/(B7*B8)

B17 asks the reverse: at your volume, how often must the manual process go wrong before automation pays? Take order entry at 200 orders a month, below its break-even of 336. Time saved is worth $4.05 an order (0.8 × 8 minutes × $0.75 a minute, less 0.2 × 5 minutes × $0.75). The monthly cost is $10.33 an order. Errors must cover the $6.28 gap at 0.7 × $150 = $105 each, so the build pays only if about 6.0% of manual orders go wrong, three times the 2% assumed. Our guide to measuring your real error rate shows how to get e from 50 real records rather than a guess.

Break-even volumes for the nine use cases (illustrative inputs from each section)
Use case	Value per case	Monthly cost	Break-even per month	Share of value from prevented errors
Quote generation	$30.00	$1,800	60 quotes	50%
Customer onboarding	$33.63	$1,650	49 new accounts	48%
Order entry from email	$6.15	$2,067	336 orders	34%
Service scheduling	$9.77	$2,375	243 jobs	33%
Returns and RMAs	$10.65	$1,242	117 returns	23%
Renewals	$145.50	$600	4 renewals	93%
Joiners and leavers	$91.75	$983	11 people	44%
Purchase requests	$11.85	$725	61 requests	30%
Compliance evidence	$86.25	$900	10 items	78%

There are two kinds of use case here. In volume use cases (order entry, scheduling, returns), roughly two-thirds or more of the value is minutes saved, so the exception rate decides the answer. In control use cases (renewals, evidence), most of the value is the error prevented, so they pay at volumes that look too small: four renewals or ten evidence items a month.

The input most worth measuring is x, the exception rate, because it hurts twice: those cases save nothing and cost extra minutes. Measure it this week. Pull the last 30 cases and mark each one that a written rule could have handled with only the data available when it arrived. The unmarked share is x. Above 40%, our rule of thumb is to fix the intake first, with a form, a required field or a mapping table, then run the numbers again.

If one of these is on your list, bring last month's volume, 30 recent cases including the awkward ones, and the systems each case touches. We would start by counting the exception rate, because that decides whether the break-even holds. Our workflow automation work starts with a single process like these.