Walk me through what a PLC, a SCADA system, a historian and an MES each do, and how they relate to ERP.

Four layers describing one physical process

Start at the bottom, because everything above it is a description of what happens there. A PLC (programmable logic controller) is a small deterministic computer wired to sensors and actuators. It runs a scan cycle — read all inputs, evaluate the logic, write all outputs — and repeats that every few milliseconds, indefinitely. The logic is written in the languages standardised by IEC 61131-3, of which ladder logic is the one you will see most. The design consequence that matters to you is this: the PLC's memory is the state of the plant. It is not a mirror of the state or a cache of it. If the register says the valve is open, the valve is open, and if your database disagrees your database is wrong.

SCADA (supervisory control and data acquisition) is the layer above, together with the HMI screens operators stand in front of. It polls or subscribes to controllers across a site, draws the process, raises alarms, and lets an operator issue supervisory commands such as changing a setpoint or acknowledging a fault. It supervises; it does not close the fast control loops, which stay in the PLC precisely so that a supervisory system going down does not stop the process.

A historian is a time-series archive of process values. It is the layer most software engineers touch first, and the one most likely to mislead them, because it looks like an ordinary database and is not. Historians usually record on change with a deadband, so the series is irregularly sampled and a two-minute gap means "this value did not move", not "data missing".

An MES (manufacturing execution system) is the layer that knows what is being made and why. It takes a production plan, breaks it into work orders and operations, dispatches them to stations, records which material lots and machine settings went into which batch or serial number, holds the operator confirmations and quality checks, and computes measures such as OEE. That record of what went into what is genealogy, and it is what makes a recall answerable in hours rather than weeks.

Where ERP fits, and why it is not the MES

ERP owns the commercial and planning view: demand, purchase orders, inventory valuation, costing, the master production schedule. The handshake is narrow and worth being able to describe. ERP sends the MES what to make and when, plus the bill of materials and the material availability. The MES sends back what was actually made, what was actually consumed, scrap and rework, and labour and machine time. ERP does not want the readings; it wants the totals it can put a price on.

The distinction is worth defending because of timescale and granularity. ERP works in shifts and days on aggregated quantities, because that is what finance needs. The MES works in minutes on individual units, because that is what a line needs. An ERP production module can hold a work order, but it will not sequence twelve stations, block a unit that failed a torque check, or reconstruct which of four material lots is inside a specific serial number.

Layer	Owns	Timescale	If it stops
PLC	Actual machine state and control logic	Milliseconds	The process stops
SCADA / HMI	Operator visibility and supervisory commands	Sub-second to seconds	Operators go blind; the process continues
Historian	The archive of process values	Seconds	You lose history, not control
MES	Work orders, genealogy, quality gates	Seconds to minutes	The line runs but cannot be released or traced
ERP	Plan, cost, inventory, orders	Hours to days	Production continues; the paperwork queues

Where instincts from web development misfire

The specific misjudgement, and the thing that separates a candidate who has done this from one who has read about it, is treating the four layers as a data stack when they are a control hierarchy. In a data stack each layer is a store you may query, and the bottom is just the slowest one. Here the bottom layer is the thing itself, and every layer above it is a late, lossy, opinionated copy that exists so the layer below can be left alone.

That single misreading produces a family of bad proposals. Reading a value directly from the PLC because it is freshest — but a poll loop a web backend would consider gentle can disturb scan timing, and a controller has no notion of a query budget. Writing a setpoint because the API allows it — but that write moves an actuator, is not a transaction, and cannot be undone by issuing the inverse. Restarting a component to clear a bad state, which here may drop the operators' view of a running line. Assuming the historian's gaps are ingestion bugs.

The habit to build instead is to ask, for every read and every write, which layer owns that fact and what the blast radius is if you are wrong. Data flows up the stack freely. Commands flow down through the systems designed to issue them, or they do not flow at all.