Rules

A rule is a named statement of what should never happen in your process — "an order is shipped before it is paid", "an invoice is cleared twice", "a block takes more than two days to release" — and a live count of how often it does. Zero is the goal.

What Rules answers

The map shows you the paths work takes. Rules let you write down which of those paths are wrong, and then keep watching. A rule is evaluated against the data every time you ask, so it is not a report that goes stale: the count on the card is how many objects are breaking the rule right now.

Open it from Rules in the project sidebar.

How a rule works

Under the hood a rule is a violation filter: an ordinary filter that matches exactly the objects breaking the rule. That means anything a filter can express, a rule can enforce — a step that happened without its prerequisite, a forbidden sequence, a duplicated event, a missing related document, an attribute that breaks a policy, a duration or a transition that took too long. It also means Show violators is one click: the rule's filter is applied to the whole project, so the map, Explore, Compare and the copilot all scope to the objects that broke it.

Creating a rule

Describe the violation in plain language — "orders that were shipped before payment was received" — and Flow Myna turns it into a filter, shows what it built in words, and gives you a live count of the objects it matches before you save anything. Name it, give it a severity (critical, high, medium or low), and save. The count is made on the lens named beside it, so you can see which object type the rule is judging.

Creating and editing rules is for project admins; anyone in the project can read them and show the violators.

The Rules page

• KPI row — how many rules, how many are currently violated, and the total violations
• Rule cards — each rule's name, severity, the current violation count and rate, and a trend sparkline built from the last thirty evaluations, with inline edit, deactivate and delete
• Evaluate now — re-runs every active rule against the current data and records a snapshot, which is what the sparklines are drawn from
• Show violators — applies the rule's filter product-wide

SLA targets are rules

A throughput target — "Block Sales Order to Unblock Sales Order within two days", "complete within fourteen days" — is stored as a rule whose violation filter matches the objects over the target. You create one with Set target on the Durations span analyser or the Health duration chart: the drawer shows the observed anchors (best demonstrated, typical, and a suggested target rounded up from the 90th percentile) with a live breach count, and saves it with a ⏱ badge. Durations then judges that transition against your target instead of against a raw average, draws the threshold on the span histogram, and counts breaches in its Targets tile.

Target rules get a guarded edit — threshold, name, severity and active only — so the target and the filter behind it cannot drift apart. Convert to custom rule unlocks the filter if you need something the target cannot say.

One limit worth knowing: a target counts objects that have both events and took too long between them. An object that is over the target but has not reached the second event yet is not counted. Being told about those — while they can still be rescued — is what alert delivery is for.

Working well with rules

• Write the rule you would enforce, not the one you can imagine. A rule with fifty violations that nobody acts on is a dashboard. Start with the two or three things that genuinely should never happen.
• Read the lens. A rule counted on Invoices answers a different question from the same rule counted on Sales Orders; the panel names the lens beside the count so you can check.
• Use Show violators, then Compare. The violators are a cohort like any other. Put them beside the rest on Compare and the reason often falls out.

Next steps

• Durations — where targets are set
• Filters & Exploration — everything a rule can be built from
• Product roadmap — alert delivery: being told when a rule starts firing

Conformance, in your own words

Classical conformance checking asks you to draw the process you meant and then scores reality against it. Rules skip the drawing: say what must not happen, and count how often it does.