# Real-Time Data with MES and ERP Integration



> Stop wasting shifts on re-typing mill certs and job cards — learn which flows to connect first for live orders, scrap and traceability.
> 
> **URL:** https://www.gosmarter.ai/blog/real-time-data-mes-erp-integration/

**Date:** 2026-08-21
**Author:** Steph Locke

**Categories:** blog

**Tags:** artificial-intelligence, data-strategy, manufacturing

## 



If your team still re-types completions, scrap and heat numbers at the end of a shift, you are not short on effort. You are stuck with **software that makes simple jobs stupid**.

I see the fix like this: connect **MES and ERP** around the flows that change today's decisions. Start with **orders, completions, scrap and traceability**. Then keep certificate data tied to the same record, so planners, QA and sales stop arguing over whose spreadsheet is right. **[GoSmarter](https://www.gosmarter.ai/), helps metals manufacturers [pull data out of mill cert PDFs](https://www.gosmarter.ai/products/mill-certificate-reader/) and line records without ripping out the systems they already own.

What you get is simple:

-   **Live order status** instead of shift-end guesswork
-   **Fewer data-entry mistakes**, with manual error rates often sitting at **1% to 4%**
-   **Faster traceability checks** for audits, customer queries and **[BS EN 10204](https://de.wikipedia.org/wiki/EN_10204)** work
-   **Lower scrap**, when planning uses current WIP and line data
-   **Cleaner [CBAM](https://taxation-customs.ec.europa.eu/carbon-border-adjustment-mechanism_en) records**, with carbon-linked production data tied to heats and shipments

This is not about feeding every field into every system. It is about moving the few data points that stop bad calls, late despatches and another evening lost to paperwork.

Here's how to fix it.

## How Do MES and ERP Work Together?

{{< youtube width="480" height="270" layout="responsive" id="t5UHo1vfw-s" >}}

## Why your ERP is always behind the shop floor

{{< image src="6a8854a6dc1e9c396e6c96a0-1787321370102.jpg" alt="MES-ERP Integration: Manual vs Automated Data Flow in Steel Manufacturing" >}}

ERP only shows what people type into it. That is the paper chase in plain sight. If someone updates the system at shift end, or not at all, your planners work from stale data. The ERP never shows what is running on the line right now.

MRP then runs on last night's stock and WIP. So the morning plan starts from yesterday's picture. Sales promise delivery against stock that has already gone. Quality puts a hold in the MES, but ERP hears about it too late to stop a despatch. Scrap gets logged on the line, then sits in limbo until someone closes the order. Your margin report looks better than the job did in real life. That gap tells you what to fix first: **which data needs to move now, and which can wait**.

| Area | The Manual Way | The Automated Way |
| --- | --- | --- |
| Order status | Paper job cards updated once per shift | Live status pushed to ERP when each operation completes |
| WIP visibility | Approximate quantities; frequent surprises | Current machine, quantity and heat/lot synchronised via events or APIs |
| Quality visibility | Paper results and emailed PDFs | Test data ingested directly; holds propagated immediately |
| Decision speed | Planners wait for reconciled paperwork | Sales and planning act on current data |
| Data trust | ERP used for finance only; operations rely on whiteboards | One version of the truth, used across operations and planning |

### Where real-time data actually saves money

Live WIP and scrap updates stop sales from over-committing capacity that does not exist. That cuts off the usual mess: expediting, panic calls, and emergency subcontracting that burns cash fast.

In a lot of plants, production operators spend hours every shift typing coil IDs, scrap weights, and test results into ERP. It is grim work, and it scales badly. When MES sends those confirmations straight through to ERP, that admin time drops while output climbs.

Manual planning often drives scrap rates to **5–8%**. Tighter scheduling based on current data can cut that to **under 2.5%** [\[3\]](/hubs/cutting-optimiser/)[\[2\]](/llms-full.txt).

CBAM adds another headache if your data is late or missing. From **January 2026**, UK exporters of steel goods to the EU face CBAM duties, so you need auditable carbon data tied to each product, shipment, order, and heat [\[5\]](https://www.fabrico.io/blog/manufacturing-execution-system-vs-erp-shop-floor/). GoSmarter links to your MES and ERP live, so you can tie each order and heat to current process data as production happens. That beats trying to rebuild the story later from paper, emails, and someone's memory at 16:45. Miss the embedded carbon data and you could add about **EUR30-EUR150 per tonne** to landed cost through CBAM certificates [\[5\]](https://www.fabrico.io/blog/manufacturing-execution-system-vs-erp-shop-floor/).

### What 'real-time' should mean in a steel plant

"Real-time" does not mean every field updates every second. That is how you end up paying for noise.

Use a simple rule instead: if this data stays wrong for the next four hours, what bad calls will you make? Production completions, machine downtime, quality exceptions, and material movements can change plans and customer promises within minutes. Those need a near-live feed. Standard costs and catalogue updates do not. You can run those overnight and sleep fine.

> The design principle is simple: **fast where it matters, batched where it does not**.

A steel plant might set service levels like **production completions within five minutes** and **quality holds propagated within one minute**. Then it can leave standard costs and catalogue updates to a nightly job. That is the line between data that drives today's decisions and data that can wait until tomorrow. It also makes the next choice much easier: **which flows to connect first**.

## Which data to move first so the line runs more smoothly

MES-ERP integration is a set of choices. It is not a big-bang project. Start with the data that pays off first. If you map every field on day one, you usually buy yourself a mess, not progress. Pick the two flows that make the biggest visible dent. Get them working. Get them reliable. Then move on. Keep traceability riding with the core order flow from the start, not bolted on later.

### Start with orders and completions, not every field at once

The best place to start is usually the same: **production orders from ERP down to MES**, and **production completions from MES back up to ERP**. The point here is simple: move the data that keeps the line moving.

When a released order goes from ERP to MES on its own, the shop floor works from a controlled order record. That means part number, heat code, quantity, due date and routing. Not a paper traveller with someone's biro notes in the margin.

When MES sends completions back, ERP gets confirmed quantities, actual times and scrap figures. Planning, stock and customer service then work from the same record. No chasing three systems and a spreadsheet to find out what happened.

In metals, the completion message needs more than "job done". It must show yield, offcuts and scrap. It must also report cut-length yields, scrap reason codes and reusable offcuts so ERP updates stock properly. If you deal with offcuts and variable cut lengths all the time, like a plate or bar service centre, this matters fast. MES should track reusable remnants as their own stock category. Then planners can assign them to short-length orders instead of buying fresh material for no good reason.

Once orders and completions run cleanly, add:

-   material consumption and WIP
-   quality results
-   downtime summaries

For downtime, keep it simple. A shift-level summary is enough for ERP. Send total unplanned downtime in minutes, top reason codes and output shortfall. That covers overhead allocation without dumping thousands of tiny stoppage events into a system that does not need them.

### Do not lose the data that matters in an audit

Do not leave traceability until later. Heat numbers, certificates, lot status and quality holds need to move with the order from day one.

Keep ERP as the master record for heats, lots and certificate metadata. MES should receive those references when you issue material. It should record which coils or billets were used in which operations. Then it should send back a usage record tied to the right heat and lot IDs on completion.

Set the rule in the integration layer: **one heat, one certificate and one lot status**. Do not patch it together when an auditor turns up and everyone starts digging through folders. That [chain, from mill certificate to shipped batch](https://www.gosmarter.ai/hubs/integrated-cert-traceability/), is what an auditor or customer quality team will actually follow.

If certificates arrive as PDFs, automate extraction into ERP so quality teams validate exceptions, not transcribe data [\[1\]](https://www.gosmarter.ai/hubs/metals-manufacturing-glossary/)[\[6\]](https://www.gosmarter.ai/hubs/mill-cert-automation). Store certificate type with the data as well. Then the plant can prove the required level of conformity when someone asks for it.

Once these flows are stable, choose the lightest integration pattern that keeps them reliable.

## Pick an integration setup your team can actually maintain

Next, pick the plumbing: direct links, middleware, or event streams. The right choice depends on three things:

-   how many systems you need to connect
-   what your team can support without living in firefighting mode
-   how fast you need the first flow live

**Point-to-point APIs** get one flow up fastest. You link ERP straight to MES with REST endpoints, send production orders to MES, then push completions back to ERP. Fine for a small, steady setup. But every new link becomes its own little maintenance trap. Your ERP vendor ships an upgrade. MES changes a field name. Suddenly the link falls over, and no one spots it until a planner is staring at yesterday's numbers. Point-to-point works for a tight set of flows. It gets messy as the estate grows. [\[15\]](https://railes.com/blog/mes-integration-guide-erp-scada-iot)[\[16\]](https://beefed.ai/en/mes-erp-integration-best-practices)

**Middleware or iPaaS platforms** sit in the middle and handle routing, transformation, and error handling in one place. They cost more to set up. They also give you one more platform to look after. But if you run multiple plants, mixed systems, or need tighter control, they save a lot of pain. You can reuse mappings. You can monitor flows in one place. [\[14\]](https://gocious.com/blog/the-product-leaders-guide-to-manufacturing-system-integration)[\[15\]](https://railes.com/blog/mes-integration-guide-erp-scada-iot)

**Event-driven architectures** with message queues or event brokers suit live shop-floor signals: machine state changes, [scrap events](https://www.gosmarter.ai/blog/how-to-calculate-scrap-rate/), quality holds. The main upside is resilience. If MES drops offline for a bit, messages wait in the queue and deliver when it comes back. They do not just vanish into the void. The trade-off is discipline. You need clear event definitions, clear producer and consumer roles, and support processes people will actually follow. [\[8\]](https://urfpublishers.com/journal/artificial-intelligence/article/view/designing-a-btp-centric-integration-mesh-for-shop-floor-iot-mes-and-erp-in-discrete-manufacturing)[\[9\]](https://www.fabrico.io/blog/mqtt-manufacturing-guide/)[\[10\]](https://blog.mesa.org/2024/02/data-mapping-ensuring-real-time-data.html)

| Integration approach | Complexity | Resilience | Fit for phased rollout |
| --- | --- | --- | --- |
| Point-to-point API | Low to medium | Low | Good for one or two flows |
| Middleware / iPaaS | Medium to high | High | Strong across multiple plants |
| Event-driven / message bus | High | Very high | Best for expanding scope over time |

Use one transaction layer for orders and postings, and one event stream for live signals. Start with the simplest pattern that supports the first flows, then extend it. [\[14\]](https://gocious.com/blog/the-product-leaders-guide-to-manufacturing-system-integration)[\[10\]](https://blog.mesa.org/2024/02/data-mapping-ensuring-real-time-data.html)

### When APIs, middleware and event streams make sense

APIs fit when one system needs to request or submit a specific business action on demand. Think creating a production order, posting a completion, or fetching master data. They are simple to build. They are easy to test. The catch is tight coupling. Change the interface on either side, and the link breaks.

Message queues start earning their keep when you cannot count on both systems being awake at the same time. Put a queue in the middle, and the completion message waits there until ERP is ready. Nothing gets lost. No one has to type the same record in again because a system had a wobble. [\[8\]](https://urfpublishers.com/journal/artificial-intelligence/article/view/designing-a-btp-centric-integration-mesh-for-shop-floor-iot-mes-and-erp-in-discrete-manufacturing)[\[9\]](https://www.fabrico.io/blog/mqtt-manufacturing-guide/)

Event streams fit when the plant needs live visibility. Not an hourly snapshot. A feed of what is happening on the line right now. They are also handy when older ERP or MES platforms cannot support clean direct integration. You decouple the systems without ripping either one out first. [\[10\]](https://blog.mesa.org/2024/02/data-mapping-ensuring-real-time-data.html)

This is where standards stop sounding academic and start saving time. **[ISA-95](https://www.isa.org/standards-and-publications/isa-standards/isa-standards-committees/isa95)** sets the boundary between Level 3 (MES) and Level 4 (ERP). It shows which system owns which data, and which transactions should cross that line. **[B2MML](https://schemas.liquid-technologies.com/b2mml/v0401/)**, its XML implementation, gives you a structured format for swapping manufacturing data like production orders, schedules, and material lots across vendors and sites. [\[11\]](https://reference.opcfoundation.org/ISA-95/v100/docs/1)[\[12\]](https://mesa.org/topics-resources/b2mml/)[\[13\]](https://engineeringservice.net/knowledge/isa-95-mes-integration-guide) That cuts the number of custom field mappings your team has to babysit and makes it much easier to repeat the setup when you add a second plant or swap a system.

That sorts the transport. Next comes the less glamorous bit: deciding which system owns each master record.

### How to stop bad data and broken syncs from undermining trust

If production confirmations fail without warning, planners go straight back to spreadsheets. You can hardly blame them. Once trust goes, the interface might as well not exist. [\[15\]](https://railes.com/blog/mes-integration-guide-erp-scada-iot)

You need failures to be visible and recoverable. Build clear error handling. Add automatic retries where they are safe. Use failed-message queues for anything that still will not deliver. Every failed transaction should trigger an alert someone can act on. Not a sad little log entry buried in a file no one opens. [\[15\]](https://railes.com/blog/mes-integration-guide-erp-scada-iot)

Validate records before they hit ERP. Reject incomplete, duplicated, or inconsistent records at the interface boundary. If a completion message is missing mandatory fields, flag it at once so the source system can fix it.

Versioning is another job teams love to skip until it bites them. Your ERP vendor pushes an update. MES adds a new field. You need to know which version of each message schema is live and whether downstream consumers can handle the change. Put explicit version control into the interface from day one. Make changes backward-compatible where you can. Run staged releases so a routine software update does not quietly wreck your production confirmation flow. [\[15\]](https://railes.com/blog/mes-integration-guide-erp-scada-iot)

For security, use least-privilege service accounts, encrypted links, and audit logs.

Before go-live, define ownership for part numbers, heat codes, and versions.

## Sort out data ownership before connecting any systems

Set record ownership before you connect anything. If you skip that step, real-time integration just spreads bad data faster. Get ownership clear first, then the rest turns into a controlled mapping job.

Use a data ownership matrix. For each critical record, name the system of record, business owner, update target and validation rule. Lock down these fields first.

| Data object | System of record | Data owner | Update target | Validation rules |
| --- | --- | --- | --- | --- |
| Part numbers / item codes | ERP | Engineering / master data team | Same day for new or changed parts | Unique code; dimensions in mm; mass in kg; no duplicates |
| Work orders | ERP | Production planning | Real-time or same shift | Valid customer PO; material allocated; status transitions valid |
| Heat codes | MES / quality tool | Quality / metallurgical engineer | Real-time on creation; updated within minutes when certificates arrive | Format match to mill certificate; unique per melt; no reuse |
| [Mill certificates](https://www.gosmarter.ai/blog/your-mill-certs-are-your-superpower/) | QA document repository | Quality assurance | Available within 24 hours of receipt; key fields validated before release | Mandatory fields present; units in MPa, %, °C; heat number matches ERP batch |
| Production completions | MES | Shop floor lead | Real-time | One completion per event; quantity produced ≤ quantity ordered |
| Scrap / remnants | MES | Operations / continuous improvement | Real-time | Controlled code list; mapped to ERP cost centre |
| Units of measure | ERP / master data governance | Master data owner | Immediate downstream sync on change | Standard code list; conversion factors validated |

### One part number, one heat code, one version of the truth

The usual cause of integration failure is not a broken API. It is two systems using slightly different names for the same thing. Mismatched part descriptions, unit-of-measure clashes and heat-number format differences all wreck matching across ERP and MES. A scrap entry of "250" means one thing in tonnes and another in kilograms. A heat number written as "H2026-0815-01" in one system will not match "20260815-1" in another.

Standardise base units. Use kilograms for mass and millimetres for dimensions. Agree one heat-number format that mirrors the mill certificate to ensure [end-to-end traceability](https://www.gosmarter.ai/blog/end-to-end-traceability-metals/). Then enforce both with validation rules that reject non-compliant records at the interface.[\[17\]](https://connect981.com/blog-posts/isa95-mes-erp-boundary-20260122)[\[18\]](https://manufacturingleadershipcouncil.com/wp-content/uploads/2024/10/MLC-Data-Mastery-Survey-10-3-24.pdf)

If every system points to the same governed master record, integration spreads correct data instead of multiplying errors.

### How to roll this out without a six-month delay

Start with the current state. List every system, every key data object and every flow between them. Note where the same item shows up under different names or units. Then set ownership for each object. Focus first on the records that will cross the integration boundary in your pilot.[\[19\]](https://www.prnewswire.com/news-releases/93-of-manufacturers-have-mes-but-only-23-have-fully-integrated-it-new-rockwell-automation-report-finds-302824247.html)

Pick one line or process for the pilot. Keep the first flows tight:

-   Work order release from ERP to MES
-   Completion and scrap reporting back to ERP
-   Certificate data feeding both

Run the pilot in parallel. Compare outputs. Cut over when they match.[\[19\]](https://www.prnewswire.com/news-releases/93-of-manufacturers-have-mes-but-only-23-have-fully-integrated-it-new-rockwell-automation-report-finds-302824247.html)

GoSmarter can ingest PDFs and CSVs, extract certificate fields, and normalise them to your governance rules without replacing ERP or MES. That means you can get to one heat code, one certificate record and one lot status before integration go-live, without a long data-cleansing exercise.

Once the pilot line is stable, extend the governance table and cleaned conventions to the next line. Reuse the patterns you have already validated. After that, the next decision is how the systems should exchange those records.

## Conclusion: start with one live data flow and build from there

The goal is not to spray data across the place and hope for the best. You need **one live flow your planners and quality team trust**. That's the bit that matters. So the practical question is simple: **which flow goes live first?**

Keep the first flow tight. Start with **orders, completions, scrap, and traceability**. That's enough to prove the setup without turning the pilot into a science project.

Pick the pattern your team can **watch, fix, and hand over** without ending up tied to an external specialist every time something breaks.

Sort out ownership before go-live. Every record needs **one source of truth**, not three systems arguing with each other.

Start with **one line, one live flow, and one clear owner**. Then pilot that flow on one line and prove it before you scale.

## Next step: pilot live certificate and production data on one line with [GoSmarter](https://www.gosmarter.ai/)

{{< image src="1892913880b1358a2a9a313f84b45010.jpg" alt="GoSmarter" >}}

Use one live line first. Prove the certificate flow there. Then scale when the data stays clean. Pick the line with the worst **[cost of mill certificate management](https://www.gosmarter.ai/blog/the-hidden-cost-of-mill-certificates/)** and the highest audit risk. Keep the pilot to **one line only**.

Start by uploading **5-10** representative mill certificate PDFs from that line into [GoSmarter's MillCert Reader](https://gosmarter.ai). It pulls out heat number, chemistry, mechanical properties, dimensions, and batch IDs. Then it links that data to the purchase order, heat code, and batch record in your ERP and MES. Once the data starts moving, track the time you save and the drop in holds. One GoSmarter customer reported saving **120 hours per year** by automating mill certificate handling and search [\[7\]](https://www.gosmarter.ai/docs/digitising-mill-certificates/).

Set a small set of clear KPIs before go-live:

-   Minutes per certificate before and after
-   Number of certificate-related shipping holds per month
-   Time to compile batch traceability documents

When the pilot line settles down, use the same mappings, rules, and checks on the next line. That gives you a pattern you can repeat without rebuilding the whole thing each time.

## FAQs

{{< faq question="What data should we integrate first?" >}}
Start with **mill certificate** and **MTR quality data** at goods-in. Pull in heat numbers, grades, chemical composition, mechanical properties, and test results. Link each one to the right stock record.

That cuts out **manual typing**. It gives you traceability from day one. It also means compliance checks and customer document requests happen on the spot, not after someone digs through emails, PDFs, and old folders.

Once that data flows into your ERP, you can add inventory and production workflow links. That's where GoSmarter, built by Nightingale HQ, starts fixing the boring software mess instead of dumping more admin on your team.
{{< /faq >}}

{{< faq question="How real-time does MES-ERP data need to be?" >}}
MES-ERP integration should be **as live as you need it**. If the shop floor changes now, your ERP should show it now. You should not wait for shift-end uploads or month-end batch jobs to find out what already happened.

In practice, you need to capture data at the point of activity. That means inventory moves, production status, quality checks and traceability fields such as heat numbers should hit ERP straight away, not hours later. Some systems update every 15 minutes. That might be fine for some modules. It might be useless for others. Check the latency you need for each module, instead of trusting a nice-sounding default.
{{< /faq >}}

{{< faq question="How do we start with one pilot line?" >}}
Start with the **biggest daily headache**. Don't try to fix everything at once. Pick the job that wastes the most time or causes the most grief, whether that's **manual certificate processing**, **inventory tracking**, or **production planning**.

Then roll it out in phases. Keep the new tools running alongside your current ERP. Import your existing master data. Test the data flows. Train operators before you switch fully. You can usually get a pilot line up and running within a week.
{{< /faq >}}