Process mapping that's good enough for AI: a 20-hour method
Every UAE operations lead is now being asked the same question: what can we automate with AI? Most cannot answer it, and the reason is not technology. Nobody has written down what the process actually does, including the exceptions and workarounds that absorb most of the effort. This article gives you a middle path between two failures: heavyweight process documentation that goes stale on arrival, and no documentation at all, where you expect the AI to "figure it out" from watching someone work. Twenty hours, five steps, one page of output that an AI engineer can build from.
Why process mapping decides what AI can and cannot do
An AI automation project has exactly one factual input: a description of the work as it really happens. The model, the framework and the hosting all matter later. First you need to know what triggers the process, what the steps are, where the data lives, what goes wrong, and where a human exercises judgement. If that description does not exist, you get one of two outcomes, and both are expensive.
The first failure mode is full formal documentation: BPMN diagrams (the OMG's BPMN 2.0 specification, published by ISO as ISO/IEC 19510), architecture frameworks, a consultancy engagement measured in months. The output is impressive and stale on arrival, because the moment it is signed off, someone changes the workaround in the spreadsheet. The second failure mode is the opposite: skip documentation, install a copilot, and expect it to learn by watching. It cannot. A person doing the job does not narrate the exception handling, and the exception handling is where automation projects die. Most teams who have shipped an AI workflow have heard the same post-launch sentence: "the AI cannot handle the exceptions."
What an AI engineer actually needs sits between these extremes: the happy path as a numbered sequence, the top 3–5 exceptions with rough frequencies, the systems touched (read versus write), and the points where judgement is required, because those become human-in-the-loop gates. That is not enterprise architecture. It is a factual brief.
There is a good empirical anchor for why observation alone is not enough. Process mining vendors such as Celonis reconstruct the real process from event logs, where every case leaves a case ID, an activity and a timestamp. What comes out is rarely one clean flow: it is hundreds of variants, the "spaghetti" of deviations from the happy path, measured with conformance checking against the process as defined. The lesson for a 20-hour exercise is not that you need process mining software. It is that the documented process and the real process diverge quietly, so your map must deliberately hunt for the deviation.
Regional timing makes this urgent. Across the UAE and the wider GCC, AI strategy conversations are happening with budgets attached before anyone has written down what the processes in scope actually do. The result is predictable: projects scoped too wide, or pilots that fail at deployment because the exceptions were never captured. Mapping one process properly is the cheapest way to turn that ambition into a factual basis for what to build first.
What "good enough for AI" actually means
Good enough is a description that lets someone who has never done the job design the automation and predict where it will break. Concretely, it must answer seven questions: what is the purpose, what triggers it, what does the happy path look like step by step, what are the exceptions, which systems are involved, where is judgement applied, and what hurts today. If any of those is blank, the scope is guesswork.
Here is how the three approaches compare:
| Full formal documentation (BPMN, framework programmes) | The 20-hour method | No documentation, AI "learns by watching" | |
|---|---|---|---|
| Time and cost | Months; external consultants; often five figures in USD | 20 hours of internal time over 2 weeks | Days, then months of remediation |
| Output | Diagrams and volumes of documents | One to two pages per process | A demo that works on clean cases |
| Exceptions captured | Yes, but often as designed rather than real | Top 3–5 with rough frequencies | No. Workarounds stay invisible |
| Staleness | High the week after sign-off | Low, cheap to re-run | Unknown until production failure |
| Who can do it | Trained process architects | An ops lead or IT manager with a note template | Vendor and hope |
| Right use case | Regulatory or ERP replacement programmes | Scoping AI automation and pilots | Nothing you intend to put in production |
The third column deserves a blunt note. Watching someone work captures the happy path beautifully and the exceptions not at all, because the experienced accounts clerk does not think of the invoices she quietly corrects as "process". That is muscle memory, and it is exactly what an interview surfaces and observation hides. Lightweight, interview-based discovery methods such as DisCOop start from that premise.
The 20-hour method at a glance
Five steps, one bounded process, two weeks of calendar time so interviews fit around the day job.
| Step | What you do | Hours | Output |
|---|---|---|---|
| 1. Bound the case | Fix the trigger, the done state, the case unit and the owner | 2 | Scope line agreed with the owner |
| 2. Happy path interview | Walk the normal case end to end with the person doing it | 5 | Numbered steps with actor and system per step |
| 3. Exceptions round | "What if?" on data, people, timing and systems | 5 | Top 3–5 exceptions with rough frequencies |
| 4. Systems and judgement | List every system, read versus write, and every human decision | 4 | Systems table and judgement points |
| 5. Write and validate | Fill the template, review with the doer and the owner | 4 | Signed one-pager per process |
Twenty hours, not twenty days. If the map takes longer than that, you are documenting the company, not scoping an automation.
The five steps in detail
1. Bound the case (2 hours)
Pick one process that hurts and is repeated often. Write a single scope line: "from X happening to Y being finished". Define the case unit, the thing you count: one supplier invoice, one customer order, one employee onboarding. Get rough volumes from the person who would know: cases per month, typical cycle time, team size. Agree the owner who can settle disputes about what the process is supposed to be. Explicitly list what is out of scope, for example credit notes and supplier queries if you are mapping invoice posting.
2. Interview for the happy path (5 hours)
Interview the person who does the work, not the manager who describes it. One question at a time, in their words: what starts this, who does the first step and in which system, what do they receive, what do they produce, what happens next. Write it as numbered steps, each with an actor and a system. Ask them to show you one real, ordinary case on screen as they talk; that catches steps people forget they do, like exporting a report to check totals.
Where two people share the work, interview both and reconcile in a 30-minute joint walkthrough. Conflicting accounts of the same step are data, not noise: note both versions and take the question to the owner.
3. The exceptions round (5 hours)
This is the step that decides whether your AI project survives deployment. Ask each question in turn: what if a field is missing, what if the approver is on leave, what if the supplier sends the wrong format, what if the amounts do not match, what if the customer replies late, what if the system is down. For every answer, capture what happens today, how often roughly (once a week, one in ten cases, rare but serious), and what it costs in delay or rework.
Listen for the artefacts that hold the real process together: the tracker spreadsheet, the WhatsApp group, the "I keep a list in my notebook". An AI integration provider puts it plainly in its own workflow mapping practice: document "the exceptions, the spreadsheets, the WhatsApp groups" before recommending anything. That is correct. Those artefacts are the process.
Rank the exceptions and keep the top 3–5 for the written output. Rare but catastrophic items (a payment to a fraudulent bank account) are kept regardless of frequency.
4. Systems and judgement points (4 hours)
List every system the case touches. For each, record whether the process only reads from it or also writes to it, who administers it, and whether it exposes an API or export. Manual copy-paste between two systems is the single most common automation target in mid-market GCC businesses.
Then mark the judgement points: the moments where a person decides something the rules do not fully determine. A price variance acceptance, a new supplier onboarding call, a VAT treatment question. Every judgement point is a future human-in-the-loop gate. If you find none in a process, you have probably not looked hard enough.
5. Write and validate (4 hours)
Fill the template below. Then validate in two short sessions: 30 minutes with the doer to check the steps are real, 30 minutes with the owner to check the rules are right. Three common disputes to settle explicitly: does the working practice or the official policy rule, who may approve an exception, and what counts as done.
The template
One page per process. This structure is deliberately flat so that both an operations lead and an AI engineer can read it without translation.
process: <name>
owner: <role>
prepared: 2026-11-20
status: draft for validation
purpose: >
One sentence: the business outcome this process produces.
trigger:
event: <what starts it>
volume: <cases per month>
done_when: <checkable end state>
happy_path:
- step: 1. <action>
actor: <role>
system: <tool>
- step: 2. <action>
actor: <role>
system: <tool>
exceptions:
- name: <what breaks>
frequency: <rough share of cases>
today: <current workaround>
cost: <delay or rework>
systems:
- name: <tool>
access: read | write
interface: API | export | manual re-key
judgement_points:
- decision: <what a human decides>
rule_source: <policy, experience, owner>
threshold: <when it applies>
current_pain: >
Quantified: cycle time, error rate, overtime, lost discounts,
late-payment penalties, or staff hours per week.
Worked example: invoice-to-payment at a Dubai distributor
Illustrative but realistic: a 40-person building materials distributor in Dubai, roughly 180 supplier invoices a month, Zoho Books as the accounting system, purchase orders sent by email, delivery notes arriving on WhatsApp.
Hours spent. Step 1: 2 hours with the finance manager to bound the case. Steps 2 and 3: two interviews of about 2 hours each with the accounts payable clerk and the warehouse supervisor, plus 1 hour of follow-up. Step 4: 4 hours listing systems and decisions. Step 5: 4 hours writing and validating. Total 20.
Happy path (abridged). Invoice arrives at the AP inbox or the WhatsApp Business line. The clerk saves it, matches it to the PO and goods received note, checks the totals, creates the bill in Zoho Books, assigns it to the payment run for the due date, and the finance manager releases the payment from the bank portal.
Exceptions (the round that mattered).
| Exception | Rough share | What happens today | Automation route |
|---|---|---|---|
| Unit price differs from PO by more than 2% | About 25% of invoices | Clerk emails the supplier and waits 1 to 3 days | Extract, flag, draft the query, human sends |
| No PO exists (verbal or WhatsApp order) | About 15% | Clerk hunts chat history, asks the buyer | Route to buyer for confirmation |
| Partial delivery against a PO | About 12% | Manual split of the invoice across deliveries | Match on delivered quantity, hold the rest |
| Scanned Arabic invoice with unclear VAT line | About 5% | Senior accountant interprets it | Extraction with low confidence, human review |
Systems. Microsoft 365 (read), WhatsApp Business (read), Zoho Books (read and write), bank portal (write, human only). The bank portal stays out of any automation scope entirely.
Judgement points. Accepting a price variance above AED 500. Any change to a supplier's bank details, which is treated as a fraud check and confirmed by phone on a known number. First invoice from a new supplier. Each one becomes an approval gate in the design.
Current pain. Median time from invoice received to posted: 2.5 days. About 22% of invoices trigger a query. Two staff spend roughly 30 hours a week on the process in total. Late-payment discounts are lost on an estimated 8% of eligible invoices.
What the scope becomes. Document intake and field extraction from email and WhatsApp, a three-way match draft against PO and goods received note, an exception queue routed by type, and human approval before anything posts to Zoho Books. Success is measured on the map's own pain numbers: median posting time under 4 hours, first-pass match rate of 60% or better, zero unattended writes to the bank. That is a build an engineer can estimate, not a vision deck.
Turning the map into an AI scope
Each section of the template drives a specific design decision. This translation is what makes the 20 hours pay.
| Template section | Design decision it drives |
|---|---|
| Purpose and trigger | The automation boundary and the events that start it |
| Happy path | The deterministic workflow or agent steps, in order |
| Exceptions | Routing rules, fallback behaviour, and the evaluation set for testing |
| Systems, read versus write | Integration work, API permissions, data residency and access control |
| Judgement points | Human-in-the-loop approval gates, with a named approver |
| Current pain | The success metrics the project is judged on |
The exception handling in particular becomes configuration rather than folklore. A fragment of what an engineer might extract from the map above:
match:
price_tolerance_pct: 2
on_variance:
within_tolerance: auto_match
above_threshold:
action: draft_supplier_query
approver: accounts_payable_clerk
escalate_if: variance_aed > 500
fraud_gate:
trigger: supplier_bank_details_changed
action: block_payment
human_check: phone_confirmation_known_number
approver: finance_manager
extraction:
low_confidence_fields: [vat_amount, invoice_date]
action: route_to_human_review
never_auto_post: true
One companion note: this process map assumes the underlying records can be read. If your data is scattered across chat exports and offline workbooks, run the data readiness check first. Our checklist Is your company data ready for AI? scores that side of the problem in an hour, with a worked GCC example.
What to do next
- Pick one process this week that is repeated often, painful, and bounded. Invoice-to-payment, quotation preparation, or customer onboarding are typical first candidates in GCC mid-market businesses.
- Block 20 hours across two weeks and name the owner who can settle rule disputes. Put the five steps in the calendar now, or the day job will eat them.
- Run the interview with the person doing the work, not the manager. Ask about last Tuesday's awkward case, not the policy manual.
- Fill the template, validate it with the doer and the owner, and stop. Resist the urge to map the whole company. Three processes mapped to this standard beat thirty mapped to a diagramming standard nobody reads.
- Hand the one-pager to whoever will build the automation and ask for a scope that addresses each exception explicitly. If a vendor's proposal never mentions your exceptions, it is priced on the happy path and will fail the moment an exception appears.
If you want a second pair of eyes on the map or on which process to start with, that is the core of our AI strategy and readiness work: we sit down with the people who run your processes and tell you plainly where AI will pay off and what it takes. Where the process first needs to be digitised and the systems connected, our digital transformation practice does that groundwork. Azrty is a Dubai company, and our own team does the consulting, the deployment and the support.
Twenty hours is the difference between an AI project scoped on facts and one scoped on hope. Spend them before you spend on tools.
Link to this article
Citing this in your own writing? Use the permanent link below.https://www.azrty.com/blog/process-mapping-that-s-good-enough-for-ai-a-20-hour-method
<a href="https://www.azrty.com/blog/process-mapping-that-s-good-enough-for-ai-a-20-hour-method">Process mapping that's good enough for AI: a 20-hour method</a> (Azrty)
