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:
| Role | Required | What it holds |
|---|---|---|
| Case id | yes | Which case (order, claim, ticket) the row belongs to |
| Activity | yes | What was done |
| Timestamp | yes | When — 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) |
| Resource | no | Who or what did it |
| Lifecycle | no | start / 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:
| Kind | Means |
|---|---|
| Skipped step | the model needed the step; the case did not do it |
| Unexpected activity | not in the model, or done again where the model does not repeat it |
| Wrong order | done, 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.
Decision tables
Decide by rules inside a process — a DMN 1.3 decision table, versioned with the process, evaluated by a decision step, branched on by a gateway, with the matched rule in the trace and the audit chain.
Forms in the gate
Give a human gate a form — the facts the signer must fill in to sign. The server checks every value, records it with the signature and the audit entry, and hands it to the steps after the gate.