How to Develop a Manufacturing Execution System (MES) with Python

Manufacturers increasingly look to build or customize their own Manufacturing Execution Systems (MES) to gain better control over production, quality, and real-time visibility. While commercial MES platforms exist, many factories choose Python-based development for its flexibility, scalability, and strong ecosystem.

This article explains how to design and develop an MES using Python, focusing on architecture, core modules, data models, and real-world factory integration.

1. What an MES Is Responsible For

Before writing any code, it is important to understand what an MES actually does. An MES operates between ERP systems and shop-floor control systems, translating production plans into executable actions and capturing what truly happens on the factory floor.

At a minimum, a practical MES should handle:

Production order execution
Work-in-process (WIP) tracking
Production reporting (good, scrap, reasons)
Machine state and downtime collection
Basic performance metrics such as OEE

More advanced functions such as traceability, quality management, and genealogy can be added incrementally.

2. Why Python Is a Good Choice for MES Development

Python has become a popular choice for manufacturing systems because it balances engineering practicality with long-term maintainability.

Key advantages include:

Mature web frameworks (Django, FastAPI)
Strong database support (PostgreSQL)
Easy integration with industrial protocols
Rich data processing and analytics libraries
Large developer ecosystem

Python allows teams to start small and grow the system organically without locking into proprietary platforms.

3. High-Level MES Architecture

A well-structured MES should separate concerns clearly. Even if implemented as a single application initially, thinking in layers avoids future rework.

flowchart TD
    ERP["ERP<br/>Production Plans"]
    MES["MES Core<br/>Execution & Tracking"]
    GATEWAY["Shop-Floor Gateway<br/>OPC UA / MQTT"]
    MACHINE["Machines & PLCs"]

    ERP --> MES
    MES --> ERP
    MACHINE --> GATEWAY
    GATEWAY --> MES

In this architecture:

ERP sends production orders and receives summarized results
Machines communicate through a gateway that normalizes signals
MES stores only meaningful production events, not raw sensor noise

4. Core Modules of a Python-Based MES

A maintainable MES is best built as a set of logical modules.

Master Data

Defines relatively stable information such as products, routings, work centers, machines, and shifts.

Work Order Management

Controls the lifecycle of production orders, from release to completion.

Execution & Events

Records what actually happens on the shop floor. This includes operation start/stop, quantity reporting, and machine state changes.

Production Reporting

Aggregates execution events into usable production metrics.

Integration Layer

Handles communication with ERP systems and shop-floor equipment.

5. Event-Driven Design: The Heart of an MES

Instead of continuously updating “current status” tables, modern MES systems use an event-driven model.

flowchart LR
    EVENT["Execution Event<br/>append-only"]
    WIP["WIP View"]
    KPI["OEE & Reports"]

    EVENT --> WIP
    EVENT --> KPI

Every significant action is recorded as an immutable event. From these events, dashboards and reports are derived.

This approach provides:

Full auditability
Easier troubleshooting
Accurate historical analysis

6. Choosing the Right Python Stack

A practical production-grade stack often looks like this:

Django for business logic and admin interfaces
Django REST Framework for APIs
PostgreSQL for transactional data
Celery + Redis for background jobs
MQTT or OPC UA libraries for machine integration
WebSockets or SSE for live dashboards

This stack is proven, widely supported, and suitable for both SMEs and large factories.

7. Connecting MES to Machines

MES should not talk directly to PLCs. Instead, a gateway layer translates machine signals into meaningful events.

flowchart TD
    PLC["PLC"]
    SCADA["SCADA / Edge Gateway"]
    MES["MES Event API"]

    PLC --> SCADA
    SCADA -->|"State / Count / Alarm"| MES

For example, a machine “RUN” signal becomes a machine_state_changed event in MES. MES does not store every sensor update—only state changes and production-relevant information.

8. Calculating OEE Correctly

OEE is not just a formula—it is a data discipline.

To calculate OEE reliably, the MES must capture:

Machine state transitions (RUN, STOP, IDLE)
Production counts (good vs scrap)
Planned production time (shift calendar)

OEE is then derived from historical events, not manually entered numbers. This prevents common issues such as inflated efficiency or inconsistent reports.

9. Scaling the System Over Time

Once a basic MES is stable, additional capabilities can be layered on:

Lot and serial traceability
Quality inspections and SPC
Genealogy tracking
Energy monitoring
Predictive analytics

Because Python systems are modular, these features can be added without redesigning the core.

10. Practical Lessons from Factory Deployments

Real factories impose constraints that software diagrams often ignore:

Network interruptions require offline-tolerant data collection
Time synchronization between machines matters
Operator interfaces must be extremely simple
Audit trails are mandatory in regulated industries

Designing for these realities from the beginning is more important than adding advanced features early.

11. Final Thoughts

Developing an MES with Python is not about building a large system upfront. It is about creating a clear execution layer that connects planning systems with the physical factory.