Work Order Lifecycle

A work order moves through up to eight statuses from creation to completion. Every transition is recorded — who did it, when, and any note they left — so you always have a full history.

Where you read the status. A badge in the Summary card’s heading row on the Overview tab, and nowhere else on the page. There is no status stepper: the badge says where the work order is, and the progress bar below it says how far the building has got.

The eight statuses

Status	What it means	Plan editable?	Build runs allowed?
`draft`	Plan is being assembled. No execution yet.	Yes	No
`ready`	Plan is marked as final; building may begin.	Yes	Yes
`in_progress`	The working state.	Yes	Yes
`paused`	Suspended as a signal to the floor.	Yes	Yes
`quality_control`	Built items are awaiting a QC review.	Yes	Yes
`qc_approved`	All built items have passed QC. Eligible for completion.	Yes	Yes
`completed`	Terminal-with-undo. Plan is frozen.	No	No
`cancelled`	Terminal-with-undo. Plan is frozen.	No	No

Only draft and the two terminal statuses stop a build run. Everything else accepts one, paused included — pausing says “nobody should be working on this”, it does not lock the door. The page reflects that: in draft the Start build run button is disabled with “Mark the work order ready first” beside it rather than hidden, and on a completed or cancelled work order it is gone entirely.

completed and cancelled are terminal but reversible. There’s no “delete” without first cancelling. In both of them every editing control disappears from the page rather than sitting there disabled.

The transition map

draft ──ready_to_start──> ready ──start──> in_progress
  │                         │                  │
  │                         └──revise_plan─────┘
  │                                            │
  └────quick_start────────────────────────> in_progress
                                               │
                                               ├─ pause ──> paused ──resume──> in_progress
                                               │
                                               ├─ submit_for_qc ──> quality_control
                                               │                          │
                                               │                          ├─ approve_qc ──> qc_approved
                                               │                          │                      │
                                               │                          │                      ├─ mark_complete ──> completed
                                               │                          │                      │
                                               │                          └─ reject_qc ──> in_progress
                                               │
                                               └─ mark_complete ──> completed   (no QC needed)

cancel: any non-terminal status ──> cancelled
uncancel: cancelled ──> previous status

There are 15 named transitions. The most common ones in everyday use:

Transition	What it does
`ready_to_start`	`draft → ready` — locks the plan as final but doesn’t start work.
`start`	`ready → in_progress` — work begins.
`quick_start`	`draft → in_progress` — combines mark-ready and start in one click.
`pause` / `resume`	Pause and resume work.
`submit_for_qc`	`in_progress → quality_control` — send built units for review.
`approve_qc` / `reject_qc`	Pass or fail the QC phase.
`mark_complete`	`in_progress → completed` (no QC) or `qc_approved → completed`. From In progress it is the main button once the work is finished.
`cancel`	Stop the work order without completing.
`uncancel`	Bring a cancelled work order back to its previous status.
`uncomplete`	Reverse a completion.

The other five — revise_plan, unstart, unapprove_qc and the two halves of the pause pair — are the reverse moves behind Move back below.

The one primary button

The work order’s title bar carries exactly one primary button, and what it says is derived from the state rather than chosen from a list. In order:

Situation	The button reads
A build run is still picking	Complete build run (takes you to the Build runs & QC tab)
`draft`	Mark ready
`ready`, or `in_progress` with work left	Start build run
`in_progress`, every item at plan, nothing waiting on QC, no open rework	Complete work order
`quality_control`	Review quality — the review itself when exactly one run is waiting, the Build runs & QC tab when several are
`qc_approved`	Complete work order
`paused`	Resume
`completed` or `cancelled`	nothing — there is no forward move

Two rules worth knowing. A pick that is still open always wins: “Send to QC” while a run is picking would strand it. And while the page is warning that the pre-assembled split is out of date, no start button is offered at all — the banner’s own Reset materials is the way out.

Everything else lives in the More actions menu beside it.

Quick start, and completing without QC

Two transitions exist specifically to skip optional waypoints:

Quick start (quick_start) — go from draft straight to in_progress, bypassing ready. Choose Start it right away in the create dialog’s After creating select, or press Quick start in the detail page’s More actions menu while the work order is still a draft.
Complete without QC — go from in_progress straight to completed, bypassing the Quality control stage. Once every item has reached its planned quantity, no run is still picking and nothing is waiting on a review, Complete work order is the primary button. Send to QC stays in More actions for when you want the extra stage; see Quality Control.

Completing without QC is always available while nothing is actually waiting on a review. If you have used QC on this work order, the completion checks apply — but only to the runs that were under QC: a run you deliberately built without it does not hold the work order up.

Moving back

Most transitions have a corresponding reverse. Rather than hunting for the right named transition, More actions offers a single entry called Move back — and it names its destination, so it reads Move back to Ready, Move back to In progress, and so on. It walks the canonical chain:

ready           → draft
in_progress     → ready
quality_control → in_progress
qc_approved     → quality_control

paused has no canonical predecessor, so Move back is not offered there — Resume is the move.

For terminal statuses (completed, cancelled) the entry is called Reopen instead. It reads the previous status that was captured when the work order entered its current state, so a completion that came from qc_approved reopens into qc_approved, while a completion that came directly from in_progress reopens into in_progress.

Cancel and reopen

You can cancel from any non-terminal status, from Cancel work order in More actions. The cancellation does not auto-cancel related entities — open build runs stay in their picking state and need to be cancelled separately. The same goes for QC reviews; cancellation doesn’t touch them.

Reopen brings the work order back to whichever status it was in before. Soft-deleted work orders (cancelled and then deleted) cannot be revived — see creating a work order → deleting.

Guards that block transitions

Each transition runs a small set of pre-flight checks. Common ones:

Plan complete (on ready_to_start and quick_start): at least one item, a production location, and no active material with a zero or negative effective quantity.
No open build runs (on mark_complete): if any build run is still in picking, you must complete or cancel it before marking the work order complete.
Items below planned (on mark_complete): every item must have built at least its planned quantity. If a build run produced fewer units than planned, you can’t complete until you build more or lower the planned quantity.
QC sign-off (on mark_complete, only if at least one QC review exists): every built unit must have a disposition, no items can still be in rework, and every run that was built for QC must have been reviewed.

If a guard blocks you, the refusal names the specific reason in plain language so you know which sub-condition needs fixing.

Concurrent edits

If two operators open the same work order in two browsers and both edit it, only one save wins — the other gets a “this work order changed under you” notice and the page reloads with the latest state. This stops one operator from silently overwriting the other’s work.

Reversing every build at once

More actions carries Reverse all builds while the work order still has runs that have not been reversed and is past ready. It reverses every non-reversed execution on the work order in one action, rather than walking the Build runs table row by row. Reversing a run gives its materials back and rolls its output away; see build runs → cancel vs. reverse.

If the work order was completed and you reverse all of its build runs, Assemblified un-completes it so the totals stay consistent.

The Activity tab

Every transition is recorded, and the Activity tab is where you read it. It is two things in one timeline:

Conversation — messages people leave on the job, written with a small formatting toolbar. Your own messages can be deleted; deleting removes them for everyone.
Progress — what actually happened: status changes, and the build-run events (pick, complete, reverse) with the quantity and the item each one touched.

A Show switch filters the feed down to All, Conversation or Progress. The progress half is append-only — it is never edited or deleted, even if the work order is later soft-deleted.

Creating a work order — the paths into draft / ready / in_progress.
Build Runs — what’s allowed in each status, and how cancellation interacts with picks.
Quality Control — the QC sign-off guards.
Glossary.