Production & Costing
Define recipes (bills of materials) and run production batches that convert raw materials into finished goods. A recipe is a reusable, industry-agnostic formula — materials in, output variants out, processing steps applied — and every run computes a full cost breakdown across materials, processing, total, per-unit cost, margin, and profit. Completing a run consumes material cost lots FIFO and creates finished-good lots at the blended production cost, so on-hand value and COGS stay accurate.
Key capabilities
- Reusable recipe templates with materials, output variants, and processing steps
- Material quantity types: percent of weight, fixed per unit, per N units, or fixed per run
- Per-material yield factor, cost per unit, and cost denomination (per unit or per weight unit)
- Multi-level BOMs — a material can resolve to a sub-recipe, rolled up recursively (cycle-protected)
- Output variants allocated by percentage, with one optional "remainder" variant for the leftover
- Processing steps with allocation by percent of total, by output variant, or across all units
- Built-in weight conversions (lb, oz, g, kg, mt) plus custom per-recipe conversion factors
- Production runs created from a recipe with total units and unit sale price
- Cost breakdown: materials by category, processing by type, total cost, cost per unit, sales potential, gross profit, gross margin %
- What-if recalculation that previews a new run size or price without saving
- Run lifecycle (draft → active → completed); completing consumes material lots and creates output lots
- Recipe duplication; materials must be linked to in-business catalog variants
- Nightly landed-cost rollup that snapshots finished-good cost from the BOM
How it works
A recipe defines inputs, outputs, and steps; a run applies them to a batch size to compute cost, and completing it moves cost through inventory lots.
flowchart LR
recipe["Recipe / BOM (materials + outputs + steps)"] --> run["Production run (total units, sale price)"]
run --> calc["Calculate: material + processing cost"]
calc --> breakdown["Per-unit cost, margin, profit"]
run --> complete{"Mark complete?"}
complete -->|"Yes"| lots["Consume material lots, create output lots"]How to use it
- Open the Production & BOMs tab (
/inventory?section=production) and click New Recipe. - Set the output unit (name, weight, and weight unit) and add any custom conversion params.
- Add materials — link each to a catalog variant, choose a quantity type and value, set yield factor and cost per unit.
- Define output variants with allocation percentages (e.g. 60% Grade A, 40% Grade B); optionally mark one as the remainder.
- Add processing steps (labor, roasting, co-packing) with an allocation type and cost per unit.
- Create a Production Run from the recipe, set total units and unit sale price, then click Recalculate to preview the breakdown.
- Review materials-by-category, processing-by-type, total/per-unit cost, and gross margin, then Mark Complete to finalize and move cost through lots.
Pro tips
- Duplicate a proven recipe to spin up a variation instead of rebuilding it from scratch.
- Recalculate is a true what-if: pass a different run size or sale price and the breakdown updates without persisting, so you can test scenarios before committing.
- Use yield factor for inputs with loss (e.g. trim or evaporation) — required quantity is divided by the yield so cost reflects what you actually buy.
- Use per N units packaging materials (e.g. one case per 12 units) — the engine rounds up to whole packaging units.
- Build sub-recipes for sub-assemblies (a sleeve that's itself film + label + glue); the rollup walks them recursively and is protected against accidental cycles.
- Mark a recipe's leftover output as the remainder variant so allocations always sum to 100% even when one stream is "whatever's left."
In-depth guide
Recipe structure
| Part | Holds |
|---|---|
| Recipe | Output unit name/weight/weight-unit, optional conversion params |
| Materials | Inputs: category, quantity type/value/unit, yield factor, cost per unit + denomination, linked variant/vendor, optional sub-recipe |
| Output variants | Finished goods: name, allocation %, remainder flag, linked variant |
| Processing steps | Vendor/process services: step type, allocation type, cost per unit |
Materials must reference an in-business, non-archived catalog variant — "custom" unlinked materials are rejected, and the material label is kept aligned to the selected variant.
Material quantity types
| Quantity type | Required quantity is… |
|---|---|
| Percent of weight | output weight × percent, then ÷ yield factor |
| Fixed per unit | quantity value × applicable units |
| Per N units | applicable units ÷ N, rounded up |
| Fixed per run | the quantity value, once per run |
Cost is quantity × cost per unit for per-unit denomination, or the weight-converted quantity × cost for per-weight denominations (e.g. per pound).
Processing step allocation
| Allocation type | Allocated across… |
|---|---|
| Percent of total | a percent of total units (or total weight when priced per weight) |
| By output variant | only the units of the listed output variants |
| All units | every unit (or total converted weight) in the run |
Output allocation & remainder
Each output variant takes its allocation percentage of the run's units; one variant may be flagged as the remainder to absorb 100% − (sum of explicit allocations). The engine computes per-variant units from these shares and uses them for both material applicability and per-variant costing.
Run lifecycle & cost breakdown
| Run status | Meaning |
|---|---|
| Draft | Created; cost breakdown computed and stored |
| Active | In progress |
| Completed | Finalized; lots consumed/created |
| Cancelled | Abandoned |
Creating or updating a run stores a cost breakdown with:
- Materials by category
- Processing by type
- Line items
- Total cost and cost per unit
- Sales potential (units × sale price)
- Gross profit and gross margin %
- Total weight in pounds
Cost-lot movement on completion
Completing a run moves cost through inventory lots:
- Consume — the calculated quantity of each material (that's linked to a variant) is drawn from FIFO cost lots.
- Sum — consumed cost plus processing-step cost.
- Create — a new cost lot per output variant at the blended total production cost × allocation% ÷ variant units.
This keeps inventory valuation and downstream COGS consistent with what the batch actually cost.
Landed-cost rollup
A nightly rollup builds a landed-cost snapshot for every finished-good variant that has a recipe:
- Materials — walks each, splitting into the material or packaging layer by category, yield-adjusted, recursing into sub-recipes.
- Processing — accumulated per unit.
- Allocation — the result is spread across output variants by their share.
- Tagging — snapshots are marked as calculated so the Landed COGS view can distinguish them from observed PO receipts.
Edge cases
- Re-completing an already-completed run is rejected.
- A sub-recipe that references itself (directly or via a chain) stops at re-entry thanks to cycle protection rather than recursing forever.
- When a consumed material has no FIFO lot available, the run falls back to the recipe's recorded cost for that line so the breakdown still balances.
Start free and cost every batch from raw material to finished unit.