Draw the path. Bulk runs the job.
Routing is the visual engine at the centre of the floor. Drag step blocks onto a canvas, wire in branches and loops, and Bulk compiles the graph into the executable rules that build every production job — no engineering cycle for a workflow change.
What is Bulk Routing?
Bulk Routing is the visual engine at the centre of the floor. You drag step blocks onto a canvas and wire in branches, loops, and automations, then Bulk compiles that graph into the executable rules that build every production job. No-code, versioned, and no engineering cycle for a workflow change.
Drag the steps. Wire the path. Compile.
A routing is a graph you draw — resource steps, decisions, do-while loops and automated actions. Hit Save & Compile and Bulk validates the structure, detects cycles, sorts every node into ordered tiers, and emits the executable rules a job runs top-to-bottom.
Five kinds of block, one canvas.
Everything on the canvas is one of a handful of node types. Drag them from the dock, wire them together, and configure each one in a focus modal — no two routings look alike, but they're all built from the same parts.
Resource step
A real manufacturing step bound to a workstation — carrying production modes, items, documents, planned minutes, a signature requirement and field-update timestamps.
Conditional split
An ordered IF / ELSE-IF decision with up to eight branches plus an implicit ELSE — the first matching formula wins, the rest are skipped.
Repeat group
A do-while container: the steps inside re-run as iterations until an exit condition is met — or a cap of up to 50 passes, then block for review or proceed with a warning.
Integration
An automated side-effect that fires inside the flow — Generate PDF against a published template, or Send Email to up to three recipients with variable substitution.
Start & End
Fixed entry and exit markers, created automatically and non-configurable — every routing begins at Start and resolves at End.
Invoicing
A special system step that may appear at most once per routing — a job is invoiced exactly once, so the compiler enforces a single Invoicing node.
First match wins.
A conditional split holds an ordered list of branches, each guarded by a typed formula. Bulk evaluates them top-down and takes the first that's true; if none match, the ELSE outlet runs. Every branch is automatically classed as a creation-time or execution-time decision.
- Ordered IF / ELSE-IFReorder branches by drag; the first true formula short-circuits the rest.
- Timing, derived for youThe compiler reads which fields a formula touches and stamps when it can decide.
- On-error fallbackChoose what happens if a formula can't resolve — true, false, skip or block.
Run it again until it passes.
Wrap a set of steps in a repeat group and they re-run as iterations until the exit condition is true. Each pass re-materialises the member steps as the next iteration — the natural shape for a make-then-check loop that shouldn't move on while there are defects.
- Exit condition formulaWhen TRUE the job moves on; when FALSE the steps run again.
- A cap that can't run away1–50 iterations; at the limit, block for review or proceed with a warning.
- Drag steps in and outMember steps sit inside the container on the canvas — drag to add or remove.
A small language for every decision.
Branches and loop exits are written in one typed expression language — field refs, aggregates and operators, with @-autocomplete as you type. The analyzer type-checks against your field catalogue and works out whether a condition decides at creation or execution time.
Edit a live routing without breaking it.
You never edit the live version in place. Every routing keeps a live (active) version that new jobs use and a working draft you compile and publish — and existing jobs keep the snapshot they were created with, no matter what you change next.
Draft
An editable version — clone the active routing or start fresh, then build on the canvas.
Compiled
Save & Compile validates the graph and emits rules; cleared whenever the workflow changes.
Active
Publishing makes it live — exactly one active version per routing; the previous one is archived.
Archived
Superseded versions are kept, read-only — the full history stays in the version drawer.
Built to bend, not break.
branches
iterations
2.1.0
version
Routing sits upstream of everything.
A routing isn't a diagram on a wall — it's the source the rest of the platform reads from. Jobs are built from it, conditions branch on live floor data, and automations fire as steps complete.
Production
The primary consumer — job creation materialises steps from the active version's compiled rules, and a single job's routing can be customised without touching the master.
Quality & Output
Supply the aggregate contexts conditions branch on — a repeat group exits on quality.count = 0; a split routes to rework when defects exist.
Settings & Master data
The authoring home — resources, production modes, items and custom fields all flow into the dock pickers and the formula field catalogue.
Questions, answered.
What is Bulk Routing?
It is a visual no-code builder for your process: drag step blocks onto a canvas, wire in branches and loops, and Bulk compiles the graph into the executable rules that build every production job.
Do I need an engineer to change a workflow?
No. Routing is a visual no-code builder, so you draw the path yourself and Bulk compiles it — no engineering cycle for a workflow change.
How do conditional branches work?
A conditional split supports up to 8 branches plus an implicit ELSE. They are evaluated top-down, and the first match wins.
Can a routing loop run forever?
No. A loop is a do-while capped at 50 iterations, so it can't run away — at the cap it blocks for review or proceeds with a warning.
What does the compiler do?
The compiler validates structure, detects cycles, topologically sorts the graph into tiers, and emits the executable rules that build every job.
What happens to jobs when I publish a new version?
There is always exactly one active version per header. Publishing archives the last one, and jobs already running keep their original snapshot.
Stop hard-coding the way you build things.
Bring one of your real processes — branches, rework loops, the lot — and we'll draw it on the canvas and compile it live, so you can watch it become jobs.