Governance you can’t skip
Make the right process
the only possible path.
Every part, design, document, BOM, and change order moves through a lifecycle you define — with gates, multi-stage approvals, and webhooks. The transitions are enforced on the server, so ‘just this once’ isn’t an option anyone can take.
Part lifecycle
server-enforcedWhat actually changes
Not “a better approval form.” A guarantee: the correct process is the only one your data will accept.
Process → the only path
Approvals stop being a memo people forget under deadline. The lifecycle is wired into the data, so the right route is the only route a record can take.
Audits with nothing skipped
Every release passed its gates because it had to. There is no hidden back door, so there is no painful reconciliation when an auditor asks.
Sign-off by construction
A part literally cannot reach “released” without its required change notice — the database, not goodwill, holds the line.
Server-enforced lifecycles
The rule lives in the data, not the screen
Each entity type gets its own state machine — draft, review, approved, released, obsolete — bound through an entity_lifecycles and workflow_entity_bindings model. A central transition_entity engine runs every move, so a clever URL, a stale tab, or a future integration can’t route around the process the way a UI-only check always eventually gets routed around.
- Configurable state machines per entity: parts, designs, documents, BOMs, change orders
- Transitions validated server-side — the UI is a view, not the gatekeeper
- Event-driven execution, no scheduled polling to lag or miss a change
- One engine governs every entity type, so behavior stays consistent
Part lifecycle
server-enforcedUn-bypassable gates
Some doors simply will not open early
Critical guards aren’t advisory. A part cannot transition to released before a required change notice exists — and that’s enforced by a database trigger, beneath every application, API, and admin button. The process isn’t something teams remember to honor; it’s a property of the records themselves.
- Hard preconditions enforced at the data layer by triggers
- Multi-stage approvals with the right sign-offs gating each step
- No “override” that quietly defeats a critical guard
- Release with confidence — the database refuses the shortcut for you
When the shortcut is impossible, nobody has to be the one who said no.
Change & audit trail
CO-2026-118- just now Released rev C · effective on next build
- 2m ago Approved by J. Kowalski (Engineering)
- 1h ago Stud spacing 24″ → 16″ o.c.
- 1h ago Linked 2 BOMs · 1 design
Wired to the rest of your stack
An approval that actually goes somewhere
Reaching a state can fire webhooks, so a release kicks off the downstream work it should — notify ERP, trigger a build packet, post to the channel your shop floor watches. Because it’s event-driven, the signal goes out the instant the transition lands, not on the next polling cycle.
- Webhooks on transitions to drive ERP, MES, and notifications
- Real-time hand-off the moment a gate is cleared
- Approvals connect the office to the floor without re-keying
1 Buyer configures
The Cascade · 3 Bed / 2 Bath
2 Product updates live
3 BOM resolves
How it works
From a draft record to a release nothing skipped
- 1
Define the lifecycle
Lay out the states and legal transitions for each entity type — parts, designs, BOMs, change orders — once, in the system that owns them.
- 2
Bind the gates
Attach preconditions and multi-stage approvals to each transition, including the un-bypassable ones backed by database triggers.
- 3
Transition server-side
Every move runs through the engine, which validates the gate, records the approval, and fires any webhooks.
- 4
Release & prove it
The record advances only when every gate is satisfied — leaving an audit trail where, by construction, nothing was skipped.
Un-bypassable approval
A change gate is a hard precondition on a state transition — a door that won’t open until a specific condition is met, such as an approved change notice before a part is released. Because Manufacts enforces it at the data layer rather than in the UI, ‘we’ll fix the paperwork later’ is impossible by construction: the transition simply will not happen until the gate is satisfied.
Learn the full spectrumUnder the hood
Everything the workflow engine does
Per-entity state machines
Configurable lifecycles for parts, designs, documents, BOMs, and change orders.
Server-side transitions
A central transition_entity engine runs every move — never a UI-only check.
Entity bindings
entity_lifecycles and workflow_entity_bindings map any record type to its lifecycle.
Change gates
Hard preconditions on transitions, with critical ones enforced by database triggers.
Multi-stage approvals
Sequenced sign-offs gate each step, with the right approvers required to advance.
Webhooks
Transitions fire events to drive ERP, MES, notifications, and downstream builds.
Event-driven runtime
Transitions evaluate the instant they happen — no scheduled polling to lag behind.
Audit-ready trail
Every gate, approval, and transition is recorded, so a release proves nothing was skipped.
Works hand-in-hand with
Every capability shares one model — so the parts connect on their own.
Visual Configurator
Turn your most complex catalog into a 3-minute buying experience — with zero impossible orders.
Pricing & Quoting
Quote every option, package, and parametric upgrade to the cent — the instant a customer picks it.
3D Showroom & Walkthrough
Let buyers walk through the exact home they configured — before a single board is cut.
See the gate the database won’t let anyone skip.
Bring the release process you’re afraid someone will short-circuit under deadline. We’ll model the lifecycle and show you a part that literally cannot reach ‘released’ without its sign-off.
No rip-and-replace — Manufacts runs alongside your ERP and CAD. Prefer email? hello@manufacts.ai