Odoo 19 for Food & Beverage:
Lot Tracking, Expiry Dates & Recipe Management

Configuring Lot and Batch Tracking for Full Upstream/Downstream Traceability

Odoo distinguishes between lots (many units share one tracking number, e.g., a 500-gallon batch of tomato sauce) and serial numbers (one unit, one number). In food & beverage, you almost always want lots. The goal is to trace any finished product back to every raw ingredient lot that went into it — and forward to every customer who received it.

Enable Lot Tracking on Product Categories

Rather than setting tracking on each product individually, configure it at the product category level. This ensures every new raw material or finished good inherits the correct tracking method automatically.

from odoo import models, fields, api

class ProductCategory(models.Model):
    _inherit = 'product.category'

    enforce_lot_tracking = fields.Boolean(
        string='Enforce Lot Tracking (F&B)',
        default=False,
        help='When enabled, all products in this category '
             'will require lot tracking at every inventory operation.',
    )

    @api.model_create_multi
    def create(self, vals_list):
        categories = super().create(vals_list)
        categories._apply_lot_tracking_to_products()
        return categories

    def write(self, vals):
        res = super().write(vals)
        if 'enforce_lot_tracking' in vals:
            self._apply_lot_tracking_to_products()
        return res

    def _apply_lot_tracking_to_products(self):
        for category in self.filtered('enforce_lot_tracking'):
            products = self.env['product.template'].search([
                ('categ_id', '=', category.id),
                ('tracking', '!=', 'lot'),
            ])
            products.write({'tracking': 'lot'})

Lot Naming Convention for Food Traceability

FDA and GFSI auditors expect lot numbers to encode meaningful information. A lot number like LOT00042 tells you nothing. A lot number like TOM-2026-03-13-A immediately identifies the product, production date, and shift. Configure Odoo's sequence to generate structured lot names:

<record id="seq_lot_food_production" model="ir.sequence">
    <field name="name">Food Production Lot</field>
    <field name="code">stock.lot.food</field>
    <field name="prefix">%(product_code)s-%(year)s-%(month)s-%(day)s-</field>
    <field name="padding">3</field>
    <field name="company_id" eval="False"/>
</record>

Lot Tracking Coverage by Operation Type

Lot numbers must be captured at every inventory movement, not just receiving and shipping. Here's where lots are recorded across the full food manufacturing flow:

Recipe Management with Bills of Materials: Yield, Byproducts, and Unit Conversion

In food manufacturing, a "Bill of Materials" is a recipe. But food recipes have complexities that discrete manufacturing BoMs don't: variable yield (flour absorbs different amounts of water depending on humidity), byproducts (whey from cheese production), unit conversions (recipes in kg, purchasing in lbs, inventory in cases), and substitution rules (sunflower oil can replace canola oil at a 1:1 ratio).

Multi-Level BoM with Byproducts

from odoo import models, fields, api

class MrpBomFoodExtension(models.Model):
    _inherit = 'mrp.bom'

    theoretical_yield = fields.Float(
        string='Theoretical Yield (%)',
        default=100.0,
        help='Expected output as percentage of total input weight. '
             'Actual yield is tracked per manufacturing order.',
    )
    recipe_version = fields.Char(
        string='Recipe Version',
        tracking=True,
        help='R&D version identifier for audit trail.',
    )
    allergen_ids = fields.Many2many(
        'food.allergen',
        string='Contains Allergens',
        compute='_compute_allergens',
        store=True,
    )

    @api.depends('bom_line_ids.product_id.allergen_ids')
    def _compute_allergens(self):
        for bom in self:
            allergens = self.env['food.allergen']
            for line in bom.bom_line_ids:
                allergens |= line.product_id.allergen_ids
            bom.allergen_ids = allergens


class MrpProductionYield(models.Model):
    _inherit = 'mrp.production'

    actual_yield_pct = fields.Float(
        string='Actual Yield (%)',
        compute='_compute_actual_yield',
        store=True,
    )
    yield_variance = fields.Float(
        string='Yield Variance (%)',
        compute='_compute_actual_yield',
        store=True,
    )

    @api.depends('qty_produced', 'product_qty', 'bom_id.theoretical_yield')
    def _compute_actual_yield(self):
        for prod in self:
            if prod.product_qty > 0:
                prod.actual_yield_pct = (
                    prod.qty_produced / prod.product_qty
                ) * 100
            else:
                prod.actual_yield_pct = 0
            prod.yield_variance = (
                prod.actual_yield_pct
                - (prod.bom_id.theoretical_yield or 100.0)
            )

The yield variance field is critical for food manufacturers. A batch of granola bars that yields 92% when the recipe expects 97% signals a problem — maybe the oat supplier changed moisture content, maybe the mixer wasn't calibrated. Tracking this per manufacturing order lets quality teams catch drift before it becomes a pattern.

Traceability Reports and Recall Management: From Farm to Fork in Under 4 Hours

The FDA's FSMA Section 204 requires high-risk food companies to provide full traceability records within 24 hours of a request. Best-in-class companies target under 4 hours. Odoo 19's traceability report (Inventory → Reporting → Traceability) shows the full chain for any lot — but only if every step was recorded with lot numbers.

Forward Trace: Raw Material → Finished Products → Customers

A forward trace answers: "This batch of flour (lot FL-2026-03-01-A) tested positive for Salmonella. Which products used it, and who received them?" Odoo's stock.traceability.report walks the move lines from receiving through manufacturing to delivery orders. The output includes:

• Raw material lot → Manufacturing order(s) that consumed it
• Finished product lot(s) produced from that MO
• Delivery order(s) that shipped those finished lots
• Customer name, delivery date, quantity for each shipment

Automating Recall Notifications

When a recall is triggered, speed matters. Configure a server action that, given a lot number, automatically identifies affected customers and drafts notification emails:

from odoo import models, fields, api
from odoo.exceptions import UserError


class FoodRecallWizard(models.TransientModel):
    _name = 'food.recall.wizard'
    _description = 'Food Recall Notification Wizard'

    lot_id = fields.Many2one('stock.lot', required=True,
                             string='Recalled Lot')
    recall_reason = fields.Text(required=True)
    recall_class = fields.Selection([
        ('I', 'Class I — Serious health risk'),
        ('II', 'Class II — Moderate health risk'),
        ('III', 'Class III — Low health risk'),
    ], required=True, default='II')

    def action_generate_recall(self):
        self.ensure_one()
        # Find all outgoing moves for this lot
        move_lines = self.env['stock.move.line'].search([
            ('lot_id', '=', self.lot_id.id),
            ('picking_id.picking_type_code', '=', 'outgoing'),
            ('state', '=', 'done'),
        ])
        if not move_lines:
            raise UserError(
                'No outgoing shipments found for lot %s.'
                % self.lot_id.name
            )

        affected_partners = move_lines.mapped(
            'picking_id.partner_id'
        )
        # Create recall record
        recall = self.env['food.recall'].create({
            'lot_id': self.lot_id.id,
            'reason': self.recall_reason,
            'recall_class': self.recall_class,
            'affected_partner_ids': [
                (6, 0, affected_partners.ids)
            ],
            'affected_qty': sum(
                move_lines.mapped('quantity')
            ),
        })
        # Send notification emails
        template = self.env.ref(
            'food_safety.email_template_recall'
        )
        for partner in affected_partners:
            template.send_mail(
                recall.id,
                force_send=True,
                email_values={
                    'email_to': partner.email},
            )
        return {
            'type': 'ir.actions.act_window',
            'res_model': 'food.recall',
            'res_id': recall.id,
            'view_mode': 'form',
        }

This wizard does in 30 seconds what most food companies do manually in 2-3 days: identify every affected customer, calculate quantities shipped, and send traceable notifications. The recall record itself becomes the audit trail — timestamped, with the responsible user, the affected partners, and the corrective action taken.

Mock Recall Drills: Test Before You Need It

GFSI-benchmarked standards (SQF, BRC, FSSC 22000) require annual mock recall exercises. These drills test whether your team can achieve full traceability — from raw material to customer — within your target time window. In Odoo, run a mock recall by:

• Selecting a random finished product lot from the last 90 days
• Running the forward trace to identify all customers and quantities
• Running the backward trace to identify all raw material lots consumed
• Timing the entire process — document the result for your auditor
• Verifying that the total quantity traced forward matches the production order output (±2% tolerance for yield loss)

If the drill takes more than 4 hours, your traceability configuration has gaps. The most common cause: manufacturing orders where raw material lots were not recorded because operators used "No Tracking" products or consumed from untracked bulk locations.

Nutrition Label Data Management

While Odoo doesn't generate FDA Nutrition Facts panels natively, storing per-100g nutrition data on product templates (as shown in the allergen model above) enables two critical workflows: automated nutrition calculation for finished products based on BoM ingredient quantities, and data export to label design software (NiceLabel, BarTender, or Loftware). The BoM-based calculation sums each ingredient's nutritional contribution proportional to its weight in the recipe — accounting for yield loss.