Manufacturing ERP Module for ERPNext and Odoo

Features

What your manufacturing module can do

BOMs that match how you really build

Multi-level BOMs with sub-assemblies, alternate items and scrap allowances per operation, loaded from the spreadsheets your engineers already keep.

Operator rules on job cards

Certifications, training records or skill levels checked before anyone logs time on a machine that can hurt them or ruin a batch.

Process loss you actually see

Loss recorded per operation, with a task for the supervisor when it crosses your limit. No more discovering it at month-end stock count.

Material planning with your lead times

Production plans that raise material requests using supplier lead times and minimum order quantities, not a single default for every item.

Costing that includes the machine

Workstation hour rates, labour and overhead rolled into the finished item's cost, so you can see which products earn their floor space.

The output

What actually gets generated

Real files in a real repository. Here’s the typical output when someone asks for manufacturing.

ERPNext / Frappe app

Operator Certification DocType linked to Employee and Workstation
doc_events on Job Card (validate and on_submit) in hooks.py
Custom supervisor field on Workstation as a fixture
BOM import script for multi-level assemblies
Process loss by operation Script Report

Odoo addon

mrp.workorder inheritance with operator certification check
Certification model linked to hr.employee and mrp.workcenter
@api.constrains blocking expired certificates
mail.activity created on mrp.production for high scrap
Inherited list and pivot views for scrap by work center

shopfloor_rules/job_card.py

import frappe
from frappe import _
from frappe.utils import flt, getdate, nowdate

LOSS_ALERT_PCT = 3

def check_operator_certification(doc, method=None):
    """Job Card.validate, wired through doc_events in hooks.py."""
    for log in doc.time_logs:
        if not log.employee:
            continue
        valid_until = frappe.db.get_value(
            "Operator Certification",
            {"employee": log.employee, "workstation": doc.workstation},
            "valid_until",
        )
        if not valid_until or getdate(valid_until) < getdate(nowdate()):
            frappe.throw(_("Row {0}: {1} isn't certified on {2}.").format(
                log.idx, log.employee, doc.workstation))

def flag_process_loss(doc, method=None):
    """Job Card.on_submit. Tells the supervisor when loss passes the limit."""
    planned = flt(doc.for_quantity)
    loss_pct = flt(doc.process_loss_qty) / planned * 100 if planned else 0
    supervisor = frappe.db.get_value("Workstation", doc.workstation, "supervisor_user")
    if loss_pct > LOSS_ALERT_PCT and supervisor:
        frappe.get_doc({
            "doctype": "ToDo",
            "allocated_to": supervisor,
            "reference_type": "Job Card",
            "reference_name": doc.name,
            "description": _("{0}% loss on {1} for {2}").format(
                flt(loss_pct, 1), doc.operation, doc.work_order),
        }).insert(ignore_permissions=True)

Trimmed excerpt. The full module includes tests, fixtures and a README.

How it works

From a paragraph to a pull request

The long version

01
Describe it

In your own words. Paste the spreadsheet or a photo of the paper form if that's easier.
02
Answer a couple of questions

It asks only what it can't work out from your setup, like who's allowed to override.
03
Try it on a sandbox

A copy of your site with the module installed. Break it, then ask for changes.
04
Merge when it's right

Code lands as a pull request with tests. Your developer, or ours, reviews it first.

BOMs are the easy part

People think the hard bit of a manufacturing ERP is the bill of materials. It isn’t. A BOM is a list, and your engineers already have it in a spreadsheet. The hard bit is everything the supervisor knows and the system doesn’t: which operator is allowed on which machine, what loss is normal on the coating line, why one job always gets split into two.

ERPNext and Odoo both handle the standard flow well. BOM, work order, operations at workstations (work centers in Odoo), material consumption, finished goods into stock. ERPNext even splits Job Cards by the batch size you set on an operation. Where they fall short is the local rules, and that’s where projects stall while someone writes a spec.

What a manufacturing ERP module from erpfly includes

On ERPNext, we generate a Frappe app with DocTypes for the things the standard product doesn’t model (operator certifications, loss thresholds, machine-specific checklists), document hooks on Work Order and Job Card, and Script Reports for the numbers your production meeting argues about. Custom fields ship as fixtures and install with bench migrate.

On Odoo, it’s an addon that inherits mrp.production, mrp.workorder and mrp.bom, adds constraints and computed fields, and extends the standard views instead of replacing them. Access rules go in ir.model.access.csv, and recurring checks run as ir.cron jobs.

Not sure which platform suits your plant? We cover that in ERP for manufacturing companies.

Worked example: a sheet metal shop with a certification rule

Say you fabricate steel enclosures. The routing is laser cutting, bending on a press brake, then powder coating. A typical Work Order is 120 enclosures.

Two rules come from your safety officer and your production manager:

Only operators with a valid press brake certificate may log time on that machine. Certificates last 12 months.
If process loss on any job passes 3%, the workstation supervisor hears about it the same shift.

On Tuesday, Marek tries to log time on the press brake Job Card. His certificate expired three weeks ago. The Job Card won’t save, and the message names the row and the machine, so the shift lead knows exactly what to fix. Ana, who is certified, takes over.

The bending finishes with 5 enclosures scrapped out of 120. That’s about 4.2%, so when the Job Card is submitted a ToDo lands with the press brake supervisor, linked to the card. A small thing, but it can be the difference between catching a worn tool today and finding 60 bad parts next week.

Notice what the prompt didn’t include. There’s no dashboard in it, no AI scrap predictor and no new approval chain. Two rules, both already enforced on paper, now enforced by the system. Changes this size are the ones that stick on a shop floor, and you can add the next rule once these two stop generating complaints.

The code on this page covers both rules. The Operator Certification DocType, a supervisor field on Workstation and the hooks entry make up the rest.

Requests we’d question

Real-time machine data through the ERP. ERPNext and Odoo are not built to swallow a reading every second. Aggregate it on the machine side and send totals per job.

A routing for every product variant. If 200 variants share three routings, build three routings. Copy-paste BOM trees are how costing goes wrong.

Backflushing everything on day one. Automatic consumption is tidy until your BOMs are slightly wrong, and at the start they always are. Record actual consumption for a month, then decide.

Planning to the minute. Scheduling a job shop to the minute in an ERP produces a very precise plan that’s wrong by lunchtime. Plan by shift or by day.

Connecting production to stock, purchasing and quality

Work orders consume stock, so inventory management has to be trusted first. Shortages turn into requests handled by purchase management, and in-process inspections belong in quality management. If you already run ERPNext, ERPNext custom module development explains how generated apps are structured, and Odoo shops should read about Odoo module development.

Guides and terms for manufacturing

Guide · ERPNext Upgrading ERPNext without breaking your customizations Updated September 10, 2026 Guide · ERPNext How to create a custom DocType in ERPNext Updated September 12, 2026 Guide · ERPNext How much does ERPNext customization cost? Updated May 6, 2026

Terms used on this page

Manufacturing module questions

Something missing? Email hello@erpfly.com and a person will answer.

Should we customise ERPNext or Odoo manufacturing, or buy a separate MES?

If you run discrete jobs with a handful of routings, customising the ERP is usually the cheaper and saner path. If you need live machine telemetry, sub-second PLC data or strict regulated batch records, a dedicated MES does that better and we'd generate the integration instead.

Which Odoo manufacturing features need Enterprise?

Manufacturing orders, BOMs, work centers and work orders are in Community. The Shop Floor tablet view, PLM, MPS and Quality are Enterprise apps. We'll tell you before generating anything that depends on an Enterprise module.

Can we import BOMs from our CAD or PDM system?

Usually yes, if it can export a flat or indented BOM to CSV or Excel. We generate an import that builds sub-assembly BOMs bottom up, so a parent never references a child that doesn't exist yet. Cleaning up messy part numbers usually takes longer than the import itself.

Will custom job card rules survive an ERPNext upgrade?

They live in your own Frappe app, hooked in through `hooks.py`, so an upgrade won't overwrite them. Manufacturing doctypes do gain fields between major versions, so run the tests we ship on a staging copy first.

How long does a manufacturing module take to go live?

The code for rules like the example on this page takes minutes. Getting BOMs, routings and workstation rates clean usually takes a few weeks of your engineers' time, and nothing we generate can skip that.

Do we own the code if we stop using erpfly?

Yes. It's a normal Frappe app or Odoo addon in your repository. Your shop floor keeps running whether or not you renew.

Operations Inventory management Your stock report says 70 units. Build it Operations Quality management Most quality problems are found too late, after the bad lot has been mixed, packed or shipped. Build it Operations Purchase management Purchasing rarely loses money in one dramatic mistake. Build it Something else? Browse every module, or describe one we haven't listed. Build it

Your next module is one paragraph away

Write it the way you’d explain it to a new hire. We’ll turn it into an app you can read, test and install.