Minctrl Docs
Guides

Process mining

Import what really happened — a CSV or XES event log, or your own run history — and see the process map with its variants, times and bottlenecks, compare it with a published version, and turn it into a draft.

A process on the canvas is what you designed. An event log is what happened: one row per thing done, with the case it belongs to, what was done and when. Process mining reads the log and draws the process from it — which paths cases really take, how often, how long they wait and where — and compares it with the version you published.

Open Process mining in the menu.

Import an event log

A dataset belongs to your company. Everyone in the company can read it (mining.read); owners, admins and managers import, rename, re-date and delete datasets (mining.manage). API keys cannot call the mining routes.

CSV

Choose CSV file and pick the file. The first 256 KB are previewed: the columns, the delimiter (, ; tab or |, detected), the first rows, and a guessed mapping. Check it:

RoleRequiredWhat it holds
Case idyesWhich case (order, claim, ticket) the row belongs to
ActivityyesWhat was done
TimestampyesWhen — ISO 8601 (2026-01-05T09:00:00Z, 2026-01-05 10:00:00+01:00), Unix seconds or milliseconds, or the strftime format you type (%d/%m/%Y %H:%M)
ResourcenoWho or what did it
Lifecyclenostart / complete — with it, the map measures how long each activity took

A timestamp without an offset is read in the time zone you give (default UTC); across a daylight-saving change the hours are counted as they really passed. A UTF-8 byte-order mark, quoted fields with a delimiter or a line break inside, and CRLF line ends are read as written. Blank lines are skipped and counted. Encodings: UTF-8 (default), Latin-1, Windows-1252.

XES

Choose XES file. XES (IEEE 1849) is the exchange format of process-mining tools; the standard extensions are read: concept:name (case and activity), time:timestamp, org:resource, lifecycle:transition, under whatever prefix the log declares for them, and <global scope="event"> defaults. The file is read as a stream, so its size does not decide the memory used.

A file that declares a DOCTYPE or an ENTITY anywhere is refused — that is how XML entity attacks (external entities, "billion laughs") arrive. The parser also runs with entities unresolved, no network and no DTD loading. XES must be UTF-8.

Your Minctrl run history

Choose My Minctrl run history, a process (or every process) and how many days back. Each run is a case; each finished step pass is an activity named by its step id. A gate a person cleared becomes a start when the run parked and a completion when it was signed, by the signer — so the map shows how long people take to sign. Passes that did not finish (parked, failed), gateways and Start/Done are not activities and are counted. A pass with no recorded time takes the time of the pass before it, and the dataset says how many did.

When rows cannot be read

Nothing is dropped without a word. A row whose case id or activity is empty, whose timestamp cannot be read, or which has the wrong number of fields is refused with its line in the file (the line the record starts on) and its data row number. If any row is refused, nothing is stored and the import shows the list; Import the N valid rows anyway stores the rest as a partial dataset, which keeps the list (the first 200, with a count of the rest) and is marked partial everywhere it is shown.

The whole file is refused when it cannot be read at all: not the chosen encoding, no header, a mapped column missing or appearing twice, malformed XML, more than MINING_MAX_EVENTS events (default 500 000), more than 1 000 distinct activities, or larger than MINING_MAX_BYTES (default 50 MB; HTTP 413).

Retention and delete

Every dataset has a retention (default 90 days, up to 3 650), counted from its import. Past it, the dataset is hidden at once and deleted with its events on the compliance worker's next pass. Changing the retention or the name, deleting a dataset and the retention deletion are each recorded in the audit chain (mining_dataset_changed, mining_dataset_deleted with reason: deleted | retention); the import is mining_dataset_imported. Entries carry the dataset's id, name and counts — never its events.

The map

The map is a directly-follows graph: an arrow from A to B when B came right after A in a case. The arrow's thickness is how often. Frequency shows the counts; Median time shows how long cases waited on each arrow (B's start, or its completion, minus A's completion) and how long each activity took where the log has start events. Start and End show where cases begin and finish.

  • Two activities that ran at the same time (B started before A completed) are counted on the arrow as an overlap, not as a wait. Two activities seen in both orders are listed as possibly parallel.
  • Rows out of time order give the same map as sorted ones; equal timestamps keep file order.
  • Bottlenecks are the three arrows where cases spend the most waiting time in total; they are drawn in rust and named "bottleneck 1–3".

Medians and p90s interpolate between values, like PostgreSQL's percentile_cont.

Simplify and filter

  • Activities shown keeps the activities seen at least that share of the most frequent one; cases are drawn through the ones kept.
  • Paths shown hides weaker arrows but always keeps every activity's strongest way in and out.
  • Cases starting from / until picks cases by when they started.
  • On Variants, tick variants to draw only those cases.

Variants and cases

A variant is a distinct sequence of activities. The table lists them by how many cases took each, with the share and the median time a case took. Cases lists every case — search by id, filter by variant, sort by start or duration — and opens one with each activity's time, who did it, how long it took and how long after the one before.

Conformance

On Conformance, choose a published process and Check conformance. Each activity is mapped to the step it names (same id or label, ignoring case and punctuation, or a close spelling); change any mapping, or set it to Not in the model, and check again.

Each variant is aligned to the model: the cheapest way to replay it, where an activity the model takes at that point is free, an activity it cannot take there costs 1 and a step the case skipped costs 1. Exclusive and parallel gateways, a gate's outcome branches and rework loops are followed. Fitness is 1 − cost ÷ (events + the shortest run of the model); a case conforms when nothing had to be skipped or added. Deviations are listed by how many cases show them:

KindMeans
Skipped stepthe model needed the step; the case did not do it
Unexpected activitynot in the model, or done again where the model does not repeat it
Wrong orderdone, but not where the model allows it

A log with more than 500 variants, or a variant too long to align, is replayed with tokens instead (fitness ½(1 − missing ÷ consumed) + ½(1 − remaining ÷ produced)); the result says which method it used.

Turn the map into a draft

On Draft from map, give the new process a slug and a name, and mark each activity as an agent step or a gate (a person signs it; role manager until you change it on the canvas). Branches that carry at least the share you choose become an exclusive choice after the activity; several start activities become a choice at the start; every activity keeps its strongest incoming arrow so none is cut off. A self-loop, and a case ending after an activity that also continues, are noted for you to add on the canvas.

The draft is saved through the same door as a canvas save — validated the same way, authored by you, state draft, audited as process_imported with source: "mining" — and opens in Processes. It needs mining.draft (members and up; it includes process.edit). A slug that is taken is refused unless you save the draft as its next version. Nothing is published: submitting and publishing follow the usual rules, separation of duties included.

On this page