If your dispatch team is copy-pasting order details from a shared Outlook inbox into a CRM all day, you can automate most of that work. The practical path is a phased workflow that uses AI to extract fields from emails and PDFs, creates a draft order in your CRM, and routes it to a human for a quick approve-or-fix review before you turn on full automation.
The real ops scenario (why this is worth automating)
A shared dispatch inbox can easily see 500 to 800 emails per day, with a mix of direct orders, quote requests, and general inquiries. In those conditions, manual order entry creates two predictable problems:
- It steals hours from customer service and dispatch.
- It introduces typos and inconsistent data.
The goal is not “fully autonomous AI.” The goal is consistent, reviewable order entry that removes the repetitive work while keeping a human in control until confidence is high.
What you are building (high-level architecture)
This guide assumes you are automating order entry from Microsoft Outlook into an external CRM.
Recommended stack:
- Inbound email capture: Outlook shared mailbox
- Orchestration layer: Make
- Extraction layer: an LLM-based structured extraction step for email bodies and PDF attachments
- Write-back: your CRM’s API
- Safety layer: human-in-the-loop review
If you want hands-on help building this live and learning as it is built, see ZoomFlow.
Step 1: Define the scope for an MVP that will actually work
Start with a narrow MVP so you can succeed quickly.
Pick 5 deterministic customers
Choose a small set of high-volume customers whose order format is consistent.
- Same email structure every time, or
- Same PDF template every time
This lets you build “known-good” extraction rules and prompts before you tackle edge cases.
Choose which message types you will automate first
Most dispatch inboxes have at least three categories:
- Direct orders (pre-negotiated pricing)
- Quote requests
- Inquiries (status, signatures, changes)
For the MVP, start with direct orders.
Step 2: Create a shared mailbox processing workflow in Make
In Make, build a scenario that:
- Watches for new messages in an Outlook shared mailbox.
- Pulls the email body, metadata, and attachments.
- Routes messages into a classification step.
Recommendation: include a “done” folder and an “exceptions” folder
A folder strategy makes operations easier:
- To process: New inbound messages
- Processing: Messages in-flight
- Done: Successfully created a draft (or final) order
- Exceptions: Anything that needs manual attention
Step 3: Classify the email before you extract
Do not extract fields from every email the same way. First, classify:
- direct order
- quote request
- inquiry
- unknown
If classification is unknown, move to Exceptions and notify the team.
Step 4: Extract order fields from email and PDF attachments (AI step)
This is the core: convert unstructured content into structured data.
What to extract (example schema)
Start with the fields your CRM requires.
- Customer
- Pickup address
- Delivery address
- Pickup time window
- Delivery time window
- Package count
- Weight (optional)
- Special instructions
- Reference numbers
Prompting tip: return strict JSON
Require the model to return a JSON object that matches your schema.
- Provide a single example input and output.
- Specify allowed values (for example, service level codes).
- Include a confidence value per field, or a single confidence score.
PDF handling
If customers send order PDFs, you will need to:
- Extract text from the PDF (OCR if needed)
- Feed that text into the same structured extraction step
Step 5: Map the extracted fields to your CRM API payload
In Make, take the extracted JSON and map it to your CRM’s create-order endpoint.
Best practice: store the raw email text and raw extracted JSON alongside the CRM record (as notes or attachments). That makes auditing and future improvements easy.
Step 6: Add a human-in-the-loop review (required for safe launch)
Before you turn on full automation, route each created order into a draft + review step.
Two common review patterns
- Draft record in CRM
- Create the order with a “Draft” or “Needs Review” status.
- A dispatcher validates and clicks “Approve.”
- Approval queue in a database
- Create a review record with the extracted fields and a link to the source message.
- A human approves, and only then the workflow writes to the CRM.
This is the phase where you improve extraction rules per customer.
Step 7: Graduate customers from “draft + review” to full automation
Only after you have a consistent history of correct extractions.
A practical graduation rule
For each customer:
- Start in review mode.
- Track error rate and common failure modes.
- Once accuracy is consistently high, enable auto-submit for that customer only.
Over time, you will have a mixed system:
- Some customers are fully automated.
- Some customers stay in review mode.
- Some customers always go to exceptions.
Common failure modes (and how to prevent them)
- Attachments missing or unreadable: Detect and send to Exceptions.
- Reply chains and quoted text: Strip quoted history before extraction.
- Multiple orders in one email: Treat as line items. If not supported, flag.
- Ambiguous addresses: Add a validation step, or send to review.
What this unlocks beyond order entry
Once orders are reliably captured, you can extend the same pipeline:
- Auto-create quote drafts for review
- Send proactive customer updates
- Track SLAs and turnaround times
Get help building this workflow
If you want this built quickly with a phased, human-in-the-loop approach, book a free discovery call and we'll help you build it.
