Intelligent pipelines vs RPA: what's actually different

Robotic process automation does one thing well: it replicates a fixed sequence of UI interactions. If a process is perfectly consistent, fully predictable, and never changes, RPA handles it reliably.

That's a real use case. Scheduled data transfers between systems. Consistent report generation. Fixed-format file processing where every input looks identical. In these situations, RPA is cheap, fast to implement, and effective.

The problems start when the inputs aren't perfectly consistent. Or when a field is occasionally missing. Or when an exception needs to be handled differently. RPA has no mechanism for any of that. It either executes the script or it fails.

An intelligent pipeline understands the content it's processing, not just the steps to execute. It can read an unstructured document and extract the relevant fields. It can assess eligibility against criteria, not just move data from point A to point B. It can detect that something looks wrong and flag it rather than processing it incorrectly.

The Cherish Grants case study is a useful illustration. A grant application isn't a fixed-format document. Applications vary in length, structure, and content. An RPA bot can't read an application and score eligibility. An intelligent pipeline can.

The difference is judgment, not speed.

Choose RPA when: the process is fully deterministic, inputs are consistent and well-formed, and the only thing you need is reliable execution of a known sequence.

Choose an intelligent pipeline when: inputs vary in format or content, the process involves classification or scoring, exceptions need to be detected and handled differently from standard cases, or the output requires synthesis rather than just movement.

Most processes that involve documents, communications, or unstructured data fall into the second category. Most processes that involve fixed-format data transfers fall into the first.

Some processes have both components. A fixed-format trigger that kicks off a variable-content extraction. A consistent filing step that follows an intelligent classification step. In these cases, the right design often combines both: intelligent processing for the judgment-intensive steps, deterministic execution for everything predictable.

The InvoiceFlow case study is an example of this. The trigger is deterministic: an email arrives, the pipeline fires. The classification and extraction steps are intelligent: the document type varies, the content varies, the vendor normalisation requires matching against a list. The filing step is deterministic again: once you know what the invoice is and what the vendor is, the naming convention and folder structure are fixed.

Designing the boundary between intelligent and deterministic processing is often where the most important architectural decisions get made.