Mail RPA in Action: How Dominik Bachmair (ACP CUBIDO Digital Solutions GmbH) Automates Inbox Work with UiPath, NLU, and BPM

Why Email RPA matters now

Email remains the start of countless business processes—from invoices and master-data changes to internal workflows. “Mail RPA” zeroes in on this reality: Robotic Process Automation takes over repetitive, rule-based inbox tasks so people can focus on high-value, creative work.

In the session titled “Mail RPA,” Dominik Bachmair (ACP CUBIDO Digital Solutions GmbH) demonstrates how a bot reads emails from Outlook, sends content to a Natural Language Understanding (NLU) engine, surfaces relevant business cases, and triggers the corresponding process—complete with human-in-the-loop via UiPath Action Center and document validation through the Validation Station. The bots run unattended within the corporate network under a central management interface; execution does not block the local machine. The talk also shows how this pattern connects to Business Process Management (BPM), exemplified with FireStart.

From our DevJobs.at editorial vantage point, here is a structured recap of the architecture, the demo flow, and key lessons engineers can apply.

The use case at a glance

The showcased bot automates processing of incoming emails in Microsoft Outlook by combining several components:

• Outlook as the inbound channel for real business events (e.g., invoices, account changes)
• An NLU engine to classify content into business cases
• UiPath as the RPA platform covering both UI automation and API integrations
• UiPath Action Center for user tasks when decisions are required
• UiPath Validation Station for document-driven extraction and confirmation
• A central management platform for unattended robots in the corporate network
• Optional: a handoff to a BPM system, exemplified with FireStart

A condensed flow:

1. The bot reads emails from Outlook.
2. Content is sent to an NLU engine to detect potential business cases.
3. If there’s a single, clear match, processing runs automatically end-to-end.
4. If multiple candidates appear, the bot creates a task in Action Center; a user selects the correct case and, if needed, the target system.
5. For document-heavy cases (e.g., an attached invoice PDF), the Validation Station opens and shows extracted fields with confidence levels for user confirmation.
6. Confirmations are saved; on similar documents next time, the bot can process them automatically.
7. Alternatively or additionally, a BPM system can initiate a workflow with forms, assignments, and full documentation.

The outcome: recurring tasks are removed from employee inboxes and executed in the background—consistently, audibly, and at scale.

Tools and architecture: how the parts fit together

UiPath as the RPA backbone

Bachmair uses UiPath to orchestrate the bot. He highlights two complementary modes:

• UI automation: click-through sequences on user interfaces
• Interface integration: connecting to other systems through APIs and connectors

This hybrid is crucial because email-driven processes are heterogeneous—sometimes structured integrations, sometimes unstructured PDFs and free text.

Natural Language Understanding (NLU)

The NLU engine acts as an intelligent classifier. It identifies relevant business cases based on email content. In the demo, it distinguishes, for example, between an “account change” and an “invoice.”

Decision logic is straightforward:

• A single, relevant match leads to straight-through processing.
• Multiple candidate cases trigger a user decision in Action Center.

Attended vs. unattended—and the management view

The process is started from the local UiPath Assistant. After the trigger, an unattended robot in the corporate network takes over. The local machine is not blocked. A web-based management interface shows that processes are running.

Action Center: human-in-the-loop

When the NLU returns multiple possible cases or when a choice is required (such as picking the target system), tasks are created in UiPath Action Center. Users make the call where it adds the most value, while the bot handles the repetitive parts.

Validation Station: document validation and learning

For invoices and other scans, UiPath Validation Station provides:

• Document classification (e.g., “invoice”)
• Language detection (100% “English” in the demo)
• Extracted fields (e.g., invoice number) with confidence scores
• Visual highlighting of where values were found in the document

Configurable thresholds govern whether the bot can auto-post an invoice or should ask for confirmation. Corrections are saved so that follow-up documents of the same pattern can run end-to-end. This applies not only to header fields but also to line items.

FireStart as the BPM example

The talk uses FireStart as an example BPM system that can orchestrate workflows with forms, assignments, and documentation. A form call can be triggered from the RPA process so that a task can be delegated—fully documented.

The demo, step by step: from inbox to completion

The live example mirrors common inbox realities. Two emails arrive:

• An email with a scanned PDF attachment—an invoice with a short message
• A simple email asking to perform an account change

The flow unfolds as follows.

1) Trigger via UiPath Assistant

The finished process is available in UiPath Assistant. A single “Play” click starts it. The bot reads emails and hands control to background execution.

Notably, the client-side step is immediately done. On the robots’ management web interface, we can see the processes running unattended. The local PC remains free.

2) Classification via NLU—and user decision

For the account change, the NLU engine returns two potentially relevant business cases. The bot therefore creates an Action Center task. A user picks the correct case—in the demo, the second option—and additionally selects the target system to continue the process. The pattern is clear: the bot prepares, a human decides, the bot continues.

3) Invoice processing in the Validation Station

For the invoice email, the Validation Station opens. It shows:

• Document type: identified as “invoice”
• Language: detected as English with 100% confidence
• Extracted key fields with confidence values (e.g., the invoice number)
• Highlighted locations of the extracted values in the document

Configurable thresholds decide whether to auto-post or to ask. Beyond header data, the engine also handles line items. The user confirms, corrects, and saves—training the system for future invoices of the same pattern.

4) Completion and learning effect

After validation, the bot stores the confirmations. Next time, similar invoices can be processed automatically depending on configured thresholds and confidence.

The downstream effect is tangible: routine steps leave the day-to-day workload. People can focus on creative collaboration and customer contact—work “no machine can take over” and that should be nurtured.

Patterns and principles behind the implementation

Bachmair’s demo highlights modern automation principles for email workflows:

• Event-driven: emails trigger processes, not the other way around
• Classification before decision: NLU reduces complexity by recommending candidate business cases
• Human-in-the-loop: ambiguity is routed to people via Action Center
• Document understanding: scanned content becomes structured data with confidence
• Confidence-driven safety: thresholds control straight-through vs. approval needed
• Continual learning: corrections improve future runs
• Decoupled execution: unattended robots run in the network; clients remain unblocked
• BPM integration: workflows, forms, assignments, and documentation are supported downstream

These principles apply broadly wherever emails initiate business processes that first need to be turned into structured decisions.

Roles and responsibilities in the flow

The session points to a clear division of responsibilities:

• Employees initiate the process, e.g., from UiPath Assistant
• Unattended robots execute workflows centrally without blocking the PC
• Business users in Action Center decide when ambiguity arises (case choice, target system)
• Clerks/analysts in Validation Station confirm extractions, manage thresholds, correct, and train
• BPM owners handle task assignment and documentation in FireStart (where integrated)

The result is a clean human-in-the-loop flow: people decide where their judgment matters; the bot handles the rest.

Technical takeaways for engineers

Even without code snippets, the talk provides concrete, applicable guidance:

• Build a mail intake flow: read from Outlook, handle attachments, and mark processing states
• Integrate NLU for case detection: send email content, parse candidate lists
• Implement decision logic: single-match equals straight-through; multi-match creates an Action Center task
• Structure user inputs: in Action Center, present choices for “business case” and “target system”
• Extract document data: send scanned PDFs to Validation Station, display fields with confidence, confirm transactions
• Configure thresholds: decide at which confidence auto-posting is allowed
• Enable learning: save corrections to automate similar documents next time
• Use unattended execution: run centrally and observe status on the management web interface
• Handoff to BPM: where appropriate, call a FireStart form to assign tasks and record the process

Combined, these building blocks form a robust, extensible architecture for email-driven business processes.

Abstracted demo workflows

Account change with multiple candidates

• Inbound: a simple email asking to perform an account change
• NLU: returns two potentially relevant business cases
• Action Center: user selects the second option and chooses the target system
• Continuation: the bot proceeds with the chosen process in the selected system

Invoice with a scanned PDF

• Inbound: an email with a scanned invoice PDF
• Validation Station: document type “invoice,” language detected as English (100% confidence), highlighted extraction with confidence values
• Decision: based on configured thresholds, either auto-post or ask for confirmation
• Learning: user saves corrections; similar invoices can be processed automatically next time

These two patterns cover a broad set of real email scenarios: unstructured text requests (master data, approvals) and document-driven processes (invoices, receipts).

Quality and operations

The talk includes pragmatic themes for quality and operations:

• Visibility: the management platform shows running processes
• Decoupling: unattended robots in the network take over execution; the client remains free
• Task control: Action Center concentrates decisions and assignments
• Auditability: FireStart (where used) documents workflows, reassignment, and outcomes
• Learning cycles: Validation Station stores corrections and improves automation rates

Together, these elements establish both transparency and scalability.

Boundaries and deliberate design choices

The demo implicitly sets healthy boundaries:

• Not every choice is automated: ambiguity is intentionally left to humans
• Automation is confidence-driven: without sufficient certainty, the bot asks instead of posting
• Customer contact remains human: creative, communicative tasks are not offloaded to bots

These are quality features, not limitations: automate where it’s robust; use human judgment where context, empathy, and discretion are required.

A practical sequence to replicate the pattern

The session suggests a clear sequence teams can follow:

1. Define email sources: which mailboxes and folders, which attachments to expect
2. Set NLU categories: which business cases to detect (e.g., invoice, account change)
3. Decide on thresholds: when to allow straight-through versus user confirmation
4. Model user tasks: which decisions go to Action Center, which options must be selectable (case, target system)
5. Specify document fields: which key values and line items should the Validation Station extract and display
6. Enable unattended operation: execute centrally and provide status visibility via the management interface
7. Plan BPM handoff: where forms, reassignment, and documentation add value (e.g., via FireStart)
8. Enable learning: persist corrections and apply them to future runs

This mirrors the path Bachmair walked in the demo—from inbox to a confident, threshold-driven automation.

Quotes and key lines that stick

• “The bot takes the work off my hands … so I can focus on the truly creative.”
• “If there is only one match, the process runs automatically; if more appear, I receive tasks to decide.”
• “Not just UI click-through, but also integrations—e.g., with FireStart or the Natural Language engine.”
• “An unattended robot somewhere in the corporate network … it doesn’t block my PC.”
• “Validation Station … 100% sure the document is in English … confidence is configurable.”
• “The engine can learn … this applies to line items as well.”

These lines capture the philosophy of the setup: solid automation, human oversight, learning document understanding, and scalable operations.

Conclusion: Email as an automation hub—structured, safe, extensible

“Mail RPA” by Dominik Bachmair (ACP CUBIDO Digital Solutions GmbH) demonstrates how emails can reliably drive business processes with UiPath, NLU, and BPM—without losing control.

• Bots read and classify emails into business cases
• Single matches run through automatically
• Ambiguous cases are routed to Action Center
• Documents are validated in the Validation Station with confidence-driven safety
• Unattended robots take over in the network while the client remains unblocked
• A management interface and optional BPM (FireStart) provide task handoff and documentation

For teams aiming to unburden their inboxes, this pattern offers a clear, practical blueprint. It’s simple and powerful: the bot does the groundwork, people make the key calls, and together they produce a process that scales—every day, for every email.