Batch & Serial Manufacturing in Odoo 19:
Traceability from Raw Materials to Finished Goods

Configuring Lot and Serial Tracking on Products and BOMs in Odoo 19

Traceability starts at the product level. Every product involved in manufacturing — raw materials, semi-finished goods, and finished products — needs its tracking method explicitly set. Odoo 19 offers three options: No Tracking, By Lots (batch tracking), and By Unique Serial Number.

Step 1 — Enable Lot and Serial Number Tracking

Navigate to Inventory → Configuration → Settings. Under Traceability, enable Lots & Serial Numbers. This unlocks the tracking field on every product form and activates lot/serial selection on all stock operations.

Step 2 — Set Tracking per Product

On each product form, go to the Inventory tab and set the Tracking field. The decision tree is straightforward:

Step 3 — Configure the Bill of Materials

The BOM defines which tracked components feed into your finished product. For traceability to work end-to-end, every tracked component must appear in the BOM with the correct product variant. Here is a sample BOM for an electronic controller with both lot-tracked and serial-tracked items:

# Create the BOM for "Smart Controller v3"
bom_id = models.execute_kw(db, uid, password,
    'mrp.bom', 'create', [{
        'product_tmpl_id': smart_controller_tmpl_id,
        'product_qty': 1.0,
        'type': 'normal',
        'bom_line_ids': [
            (0, 0, {
                'product_id': pcb_board_id,        # Tracked: By Lots
                'product_qty': 1.0,
            }),
            (0, 0, {
                'product_id': capacitor_kit_id,     # Tracked: By Lots
                'product_qty': 4.0,
            }),
            (0, 0, {
                'product_id': power_supply_id,      # Tracked: By Serial Number
                'product_qty': 1.0,
            }),
            (0, 0, {
                'product_id': enclosure_id,          # No Tracking
                'product_qty': 1.0,
            }),
        ],
        'operation_ids': [
            (0, 0, {
                'name': 'SMT Assembly',
                'workcenter_id': smt_line_id,
                'time_cycle_manual': 12.0,
            }),
            (0, 0, {
                'name': 'Functional Test',
                'workcenter_id': test_bench_id,
                'time_cycle_manual': 8.0,
            }),
            (0, 0, {
                'name': 'Final Assembly & Serial Assignment',
                'workcenter_id': assembly_station_id,
                'time_cycle_manual': 15.0,
            }),
        ],
    }]
)

Serial Number Assignment at Work Orders: Per-Unit Tracking Through Operations

For serial-tracked finished goods, each unit gets a unique identifier. In Odoo 19, serial numbers can be assigned at specific work order operations — typically the final assembly or quality check step. This means you know not just what was produced, but which workstation and which operator handled each unit.

Step 1 — Enable Work Orders

Go to Manufacturing → Configuration → Settings and enable Work Orders. This activates the routing (operation sequence) on BOMs and creates individual work orders for each operation when a manufacturing order is confirmed.

Step 2 — Configure Serial Assignment on the Last Operation

On the BOM, set the Manufacturing Readiness field to define when serial numbers are required. Best practice: assign serials at the last operation (typically final assembly or QC inspection) so that scrapped units from earlier operations don't consume serial numbers.

# Generate sequential serial numbers for a batch of 50 units
product = env['product.product'].browse(controller_product_id)
serials = []

for i in range(1, 51):
    serial = env['stock.lot'].create({
        'name': f"SCV3-2603-{{str(i).zfill(5)}}",
        'product_id': product.id,
        'company_id': env.company.id,
    })
    serials.append(serial.id)

# Assign serials to the manufacturing order
# Each unit in the MO gets one serial from the list
mo = env['mrp.production'].browse(mo_id)
mo.action_confirm()

# Process work orders one unit at a time
for idx, wo in enumerate(mo.workorder_ids.filtered(
    lambda w: w.state == 'ready'
)):
    wo.button_start()
    # At the final operation, assign serial
    if wo.is_last_unfinished_wo:
        wo.finished_lot_id = serials[idx]
    wo.button_finish()

Step 3 — Tablet Interface for Shop Floor Operators

Odoo 19's shop floor module provides a tablet-friendly interface for operators. At each work order, the operator sees: the operation instructions, required components (with lot numbers pre-selected by FEFO/FIFO), a barcode scan field for the serial number, and quality check points if configured. The operator scans or enters the serial, completes the operation, and moves to the next unit.

<!-- In your custom module: views/mrp_workorder_views.xml -->
<record id="quality_point_serial_scan" model="quality.point">
    <field name="name">Scan Serial Number Label</field>
    <field name="product_ids"
           eval="[(4, ref('product_smart_controller_v3'))]"/>
    <field name="picking_type_ids"
           eval="[(4, ref('mrp.picking_type_manufacturing'))]"/>
    <field name="operation_id"
           ref="mrp_operation_final_assembly"/>
    <field name="test_type">passfail</field>
    <field name="note">
        Scan the printed serial label. Verify it matches
        the label on the unit enclosure. If mismatched,
        flag for rework.
    </field>
</record>

Executing a Product Recall in Odoo 19: Quarantine, Notify, and Document

When a quality issue surfaces — a failed lab test, a customer complaint, a supplier notification — the clock starts. Regulatory bodies like the FDA expect documented recall actions within 24 hours of identifying a safety concern. Here is the step-by-step recall workflow using Odoo 19's native features.

Step 1 — Identify Affected Lots

Use the downstream traceability report (described above) to identify every finished goods lot that contains the affected raw material. Record the manufacturing orders, finished lot numbers, quantities produced, and quantities already shipped.

Step 2 — Quarantine In-Stock Units

Create a scrap location or dedicated quarantine location (Inventory → Configuration → Warehouses → Locations). Then move affected lots from stock to quarantine:

# Define the quarantine location
quarantine_loc = env['stock.location'].search([
    ('name', '=', 'Quarantine'),
    ('usage', '=', 'internal'),
], limit=1)

# For each affected finished lot still in stock
for lot in affected_finished_lots:
    quants = env['stock.quant'].search([
        ('lot_id', '=', lot.id),
        ('location_id.usage', '=', 'internal'),
        ('location_id', '!=', quarantine_loc.id),
        ('quantity', '>', 0),
    ])

    for quant in quants:
        # Create an internal transfer to quarantine
        picking_type = env.ref('stock.picking_type_internal')
        picking = env['stock.picking'].create({
            'picking_type_id': picking_type.id,
            'location_id': quant.location_id.id,
            'location_dest_id': quarantine_loc.id,
            'origin': f"RECALL-{{recall_reference}}",
            'move_ids': [(0, 0, {
                'name': f"Quarantine: {{lot.name}}",
                'product_id': lot.product_id.id,
                'product_uom_qty': quant.quantity,
                'product_uom': lot.product_id.uom_id.id,
                'location_id': quant.location_id.id,
                'location_dest_id': quarantine_loc.id,
            })],
        })
        picking.action_confirm()
        picking.action_assign()
        # Set the lot on the move line
        picking.move_line_ids.write({
            'lot_id': lot.id,
            'quantity': quant.quantity,
        })
        picking.button_validate()

Step 3 — Notify Affected Customers

Using the delivery data from the traceability report, generate a recall notification list. Odoo's mail templates can automate this:

# Build customer recall notifications
for delivery in affected_deliveries:
    partner = delivery.move_id.picking_id.partner_id
    lot_name = delivery.lot_id.name
    product_name = delivery.product_id.name
    delivery_ref = delivery.move_id.picking_id.name

    # Create and send the recall email
    template = env.ref('your_module.recall_notification_template')
    template.with_context(
        lot_name=lot_name,
        product_name=product_name,
        delivery_ref=delivery_ref,
        recall_ref=recall_reference,
    ).send_mail(partner.id, force_send=True)

Step 4 — Document for Compliance

Regulatory audits require documented proof of recall execution. Use Odoo's chatter on the affected manufacturing orders and lots to log every action: when the issue was identified, who authorized the quarantine, which customers were notified, and the disposition of recalled units (rework, scrap, or return to supplier). Every chatter message is timestamped and tied to a user — this is your audit trail.