Core Concepts & Data Flow
The mental model behind the Production module: the two layers you can switch on, the handful of objects you work with, and exactly how a production run moves stock through Inventory. Learn this once and every feature page will make sense.
The two layers
The module ships as two layers that you enable independently. They live in the same package but are gated by two separate toggles, one nested beneath the other.
The essential make-to-stock loop that the running module actually delivers:
Work Centers, a Bill of Materials (components + routing operations),
Manufacturing Orders with a draft → confirmed → in_progress → done
lifecycle that posts real stock to Inventory on completion, plus an overview dashboard and
Production Reports.
A deeper shop-floor toolkit layered on top: Work Orders,
Quality Control (plans, inspections, NCR, CAPA), Material Requisitions & issues,
Costing (standard vs. actual), Labor & downtime tracking,
Compliance Documents, and Engineering Change Orders (ECO). It uses its own
manufacturing_* tables.
Toggle beneath a toggle
The two layers are switched on in Settings → Manage Modules and are gated hierarchically:
module_manufacturing only takes effect while module_production is on —
the Advanced sub-area sits beneath the master switch. You can run Base Production alone,
or turn on both. Turning off Production hides both sidebar groups. See
Getting Started for the activation steps.
module_billofmaterials / module_productions. That is a different,
legacy feature — everything on these pages refers to the modern Production module and its
two toggles above.
The core objects
Almost everything in Base Production is built from five objects. Learn these definitions and the rest of the guide reads easily. Each links to its own feature page.
| Object | What it is | Where it comes from |
|---|---|---|
| Work Center work-centers.html |
A production resource — a machine, labor station, assembly line, inspection or packaging station — where routing operations are performed. Carries a capacity per hour and a cost per hour, and an active/inactive status. | Master data you create once in Production. Stored in work_centers. |
| Item / Finished Good | Any product or raw material tracked in stock. In a BOM, the finished good is the
product being produced; components are the raw materials consumed. Only active
items of type product appear in the pickers. |
Owned by Inventory, not Production — items / item_variants /
units. Stock is tracked against each item's default_variant_id. |
| Bill of Materials (BOM) bom.html |
The recipe for one finished good: a header (which product, the output quantity + unit, a version/reference, a status), plus two detail lists — Components (the raw materials, each with a quantity and unit) and Operations (the ordered routing steps at work centers, each with a sequence and duration). | You build it in Production. Stored in boms, bom_components,
bom_operations. |
| Manufacturing Order (MO) manufacturing-orders.html |
One actual production run: "produce X units of finished good Y, optionally following BOM Z."
Carries planned vs. produced quantities, an auto reference like MO-00001, and
a status lifecycle. On completion it posts stock movements to Inventory. |
You raise it in Production. Stored in manufacturing_orders +
manufacturing_order_components. |
| Work Order (WO) Advanced |
The Advanced-layer equivalent of an MO — an executable production instruction for the shop
floor, numbered with a WO- prefix, carrying ordered/produced/scrapped
quantities, batch and lot numbers, and a slightly different status set. |
Only present when Advanced Manufacturing is enabled. Stored in
manufacturing_work_orders. |
manufacturing_orders,
statuses draft/confirmed/in_progress/done/cancelled). The Advanced layer uses the
Work Order (manufacturing_work_orders, statuses
draft/released/in_progress/completed/cancelled) — its table was deliberately renamed
to avoid colliding with the base MO. Confirmed ≈ released; done ≈
completed.
How production flows
The whole of Base Production is one short pipeline. You set up work centers once, define a recipe per product, then run that recipe to turn stock into finished goods.
The two moments that move data
Nothing about a Manufacturing Order touches your stock until two specific lifecycle actions fire. Understanding these two moments is the single most important thing on this page.
-
On Confirm — the recipe is snapshotted onto the order
When you confirm a draft MO, the system copies each of the BOM's component lines into the order's own component list (
manufacturing_order_components), scaled to the planned quantity. The scaling factor isQuantity to Produce ÷ BOM output quantity, so a BOM that yields 1 unit, run for a planned quantity of 100, multiplies every component by 100. This snapshot means later edits to the BOM never rewrite the history of an order already confirmed. Confirm does not move any stock — it only plans the materials. -
On Complete (Mark as Done) — stock is posted to Inventory
When the order is marked done, the system writes real stock movements to
item_inventories: each component is consumed (flow'-', quantity = its Required Quantity) and the finished good is produced (flow'+', quantity = Quantity Produced, defaulting to the planned quantity). Each line's Consumed Quantity is set equal to its Required Quantity, and the order is flaggedstock_posted = 1so it can never post twice.
What the completion writes to Inventory
Every stock movement is a row in item_inventories, tracked against the item's
default variant (items.default_variant_id). A single MO completion writes one
consumption row per component plus one production row for the finished good:
| Movement | Flow | Quantity | Against |
|---|---|---|---|
| Each component consumed | flow '-' | The line's Required Quantity | Component item's default_variant_id |
| Finished good produced | flow '+' | Quantity Produced (defaults to Quantity to Produce) | Finished good's default_variant_id |
item_inventories. The BOM output quantity and component quantities are just planning
figures; the real, up-to-the-minute on-hand number always lives in Inventory.
The Manufacturing Order lifecycle
An MO moves left-to-right through five states. Only two of them touch stock, and the last two are terminal.
The full step-by-step for each transition, its confirmation dialog, and its guards live on the Manufacturing Orders page.
Base vs Advanced object map
The same concepts exist in both layers, but they are stored in different tables. Base
Production uses six lean, un-prefixed tables — this is what the running UI reads and writes. The
Advanced layer adds its own manufacturing_* tables. Use this map whenever you need to
know which table a screen is backed by.
Base Production tables the live model
| Table | Purpose |
|---|---|
work_centers | Production resources where operations run (capacity/hour, cost/hour, status). |
boms | Bill of Materials header — the recipe for one finished-good item (output quantity + unit, version, status). |
bom_components | Raw-material lines of a BOM — an item + quantity + unit needed to make the BOM's output. |
bom_operations | Routing steps of a BOM — the ordered operations at work centers (sequence, duration). |
manufacturing_orders | A production run turning components into a finished good; carries the draft→done lifecycle and the stock_posted flag. |
manufacturing_order_components | Per-order snapshot of required materials, copied from bom_components (scaled) at Confirm; tracks required vs. consumed. |
Advanced Manufacturing tables module_manufacturing
| Table | Purpose |
|---|---|
manufacturing_work_centers | Richer work-center master data (type, setup time, location, capacity UoM) than the base work_centers. |
manufacturing_bom | BOM headers with versioning, effectivity dates, and an approval workflow (draft/pending_approval/approved/obsolete). |
manufacturing_bom_items | BOM component items with scrap %, optional items, and substitutes; supports multi-level BOMs. |
manufacturing_bom_operations | BOM routing/operations with setup + run time, costing rates, and outsourcing. |
manufacturing_work_orders | Advanced Work Orders (renamed from manufacturing_orders to avoid collision) with lot/batch, assignee, and ordered/produced/scrapped quantities. |
manufacturing_order_operations | Per-order operation tracking — planned vs. actual times and quantities completed/scrapped. |
manufacturing_orders (an MO with
quantity_planned/quantity_produced and VARCHAR statuses) is not the
Advanced Work Order. The Advanced layer's production-run table was deliberately renamed to
manufacturing_work_orders. When in doubt about which one a report or query hits, check
the table name against this map.
How it connects to the rest of ERPat
Production is not an island — it sits on top of Inventory and, in the Advanced layer, adds quality, material, cost, labor, and compliance records that hang off a production run.
Inventory — the foundation
The base module reads and writes core Inventory through the shared application models, so it works whether or not the Inventory UI is enabled — but the items must exist first.
| Inventory object | Role in Production |
|---|---|
items | Master list of finished goods and raw materials. Pickers offer only active items of type product. Supplies default_variant_id, unit_id, cost and sell amounts. |
item_variants | The stock-bearing variant of an item. The display title comes from the item's default variant; stock movements post against default_variant_id. |
units | Units of measure (pcs, kg, L, …) for BOM output, component lines, and MO quantities. Posting falls back to the item's own unit if a line has none. |
item_inventories | The stock-movement ledger. MO completion writes one flow '-' row per consumed component and one flow '+' row for the produced finished good. |
Where the Advanced records attach
When Advanced Manufacturing is on, several record types hang off a Work Order (or its operations) to add quality, material, cost, and labor detail. Each has its own feature page.
| Attaches to | What it adds | Feature page |
|---|---|---|
| Quality Control — inspection on an order/operation | QC plans define what to check and how (sampling); inspections record pass/fail; failed inspections feed NCRs and NCRs feed CAPAs. | quality-control.html |
| Material Requisitions — request against an order | A request to draw materials from stock (draft → submitted → approved → issued), with line items and actual material issues. |
material-requisitions.html |
| Costing — standard cost per product, actual cost per order | Standard (expected) material/labor/machine/overhead cost vs. the order's actual cost, with variance and variance percentage. | costing.html |
| Labor Tracking — time on an order/operation | Labor hours per employee (direct/indirect/setup/rework) with hourly rate and cost, feeding actual cost. | labor-tracking.html |
| Compliance Docs — permits/certificates | Philippine regulatory documents (DTI, BIR, DOLE, FDA, DENR, ISO) with issue/expiry dates and renewal alerts. | compliance.html |
| Engineering Changes (ECO) — controlled change to a BOM | A request to create/revise/obsolete a BOM through submit → review → approve → implement (or reject). |
engineering-changes.html |
Where to go next
Now that the mental model is in place, dive into the feature that matches your task.
Define the resources where operations run — capacity, cost, status.
Build the recipe: header, components, and routing operations.
Run the recipe through the draft → done lifecycle and post stock.
Order status, component consumption, and output by period.
The deeper toolkit: work orders, QC, requisitions, costing, and more.
Every term, status, and badge colour defined in one place.