Buying, Building and Using What You Have

The core of process mining is a group-by over an event log. The purchase decision should follow the first analysis, not precede it.

What you can do with what you have

Build the log in SQL, which is where most of the work is anyway.

Compute cycle times, waiting times, rework rates and variant counts with ordinary queries.

Produce the variant list ranked by volume and cost.

Check conformance rules as SQL assertions, which is frequently clearer than a fitness score.

Chart it in whatever you already use.

This gets you most of the findings on the first process and costs nothing but time.

What a platform adds

Discovery visualisation, which is genuinely hard to build and useful for orientation.

Interactive filtering, which speeds exploration substantially.

Connectors to common source systems, which saves real extraction effort.

Conformance against a model, rather than against rules.

Refresh orchestration and alerting.

Access control, which matters where the resource field is present.

The connectors, the interactivity and the orchestration are the real purchase. The algorithms are published.

When building is defensible

One process, where a query set is adequate.

Existing data engineering capacity with a named owner for three years.

A warehouse where the log naturally belongs, so the extract serves other purposes too.

Source systems with no vendor connector, where you would build the extract regardless.

A short question that a chart answers.

When it is not

When nobody will own it, because an unmaintained pipeline produces frozen numbers that are still quoted.

Several processes, where the orchestration and mapping maintenance becomes the job.

When interactive exploration is the requirement, which is tedious to build and is what analysts actually use.

When the driver is avoiding a licence cost smaller than the engineering time.

Evaluating a platform

Trial on your own log, including the defects. A demonstration on clean sample data proves nothing.

Ask what it does with same-second events and with incomplete cases, since the defaults determine the map.

Ask whether the mapping and exclusion rules are visible and exportable, because that is the artefact you cannot rebuild cheaply.

Ask about the identity model: can it enforce aggregation of the resource field, or is it a reporting filter over individual records.

Export everything during the trial and check it rebuilds.

Log your own hours, which is the cost never in the business case.

The middle path

Build the log and the mapping in your own environment.

Buy the tool that reads it for discovery, exploration and refresh.

Keep the log and mapping outside the tool, so a change of vendor costs weeks rather than a restart.

This is the arrangement most organisations should aim at, and it requires doing the first analysis before going to market.

Doing the first analysis manually

The exercise that produces the requirement.

Build the log in SQL and chart it in whatever you already use.

Deliver one finding and act on it.

Note what was tedious: interactive filtering, variant exploration, refresh orchestration.

Those pain points are the requirement, and they are narrower than any vendor's feature list.

It also teaches the team more than any course, because every decision — identifier, boundary, mapping, exclusions — has to be made explicitly rather than accepted from a default.

The trial checklist

Six things to do during an evaluation so the decision rests on evidence.

Load your own log, defects included.

Check the defaults: same-second ordering, incomplete case handling, filtering.

Export the mapping and exclusion rules and confirm they are usable outside the tool.

Test the identity model: attempt to produce an individual-level report and see whether the aggregation is enforced or filtered.

Run one real finding end to end, including the re-measurement.

Log your own hours, which is the cost never in the business case.

What you can do without a licence

More than vendors suggest, and it produces the requirement.

Extract three columns and count variants in a spreadsheet.

Compute duration percentiles and the waiting proportion.

Count rework loops with a self-join.

Segment by case attribute.

All of it in SQL and a pivot table, for one process, in days.

Buy for the discovery visualisation, the maintained connectors and the workflow layer, which are the real purchase. The variant count is not.