Our client is a large-scale European flour milling and food processing group — a continuous, document-heavy, time-sensitive production operation running multiple milling tracks and lines. Its machines already think for themselves: PLCs and industrial sensors run the local loops. But the data they produce was trapped at the edge — logged on paper, relayed verbally, and reassembled in Excel after the shift ended. Graffino architected the missing layer: an on-premise, real-time process observability system built on top of the existing automation hardware, designed to wrap around how the plant actually works.
The operation
The process at the center of the engagement is a multi-stage, starch-based mixture preparation line. Starch and water are dosed and combined in a secondary mixing unit, then blended in a closed tank. Steam heats the mixture while operators watch the parameters climb toward a target temperature. When the threshold is reached, a pump transfers the batch to a second, open tank — and there, pressure is the decision-maker: it determines exactly when the transfer pump shuts off.
Weighing and dosing run on a separate electronic dosing system in manual and automatic modes. The physical stages, as the plant runs them:
The friction
The structural problem sat at the intersection of the physical factory floor and digital visibility:
One more constraint shaped everything: a previous attempt at a fully automated, hands-off mixing cycle had already failed in this plant. Raw materials are physically unpredictable; the process needs human judgment at specific points. Whatever got built had to respect that.
Full automation already failed here once. The system has to wrap around real-world human interventions — not pretend they don't exist.
The approach
The mandate was pragmatic: a localized, on-premise monitoring and observability layer on top of the automation hardware the plant already trusts. Three principles ran through the architecture:
What we architected
On-premise servers reading asynchronous telemetry directly from the edge PLCs and embedded sensors over standard industrial protocols.
Ingestion scripts that parse continuous raw event streams, apply runtime/downtime logic rules, map anomalies and reconcile conflicting versions of data truth.
Hardware events translated into structured SQL blocks — a local-network PostgreSQL store holding high-resolution temperature and pressure profiles over time.
A lightweight React/Next.js interface delivering real-time plant-level rollups, scannable line dashboards and historical diagnostic timelines.
Running outputs and batch lot consistency made visible per line — replacing guessing and operator-chasing with status timelines.
Runtime trends, stoppages and mechanical anomalies logged automatically at the source — visible during the shift, not reconstructed after it.
High-stakes tracking of the pressure variations that precede a transfer-pipe clog — the data foundation for warnings before a hazard, not after.
Digital tracking for the refill-during-transfer stage that maximizes output — the critical parallel process that previously ran unmonitored.
Inside the architecture
Before / after
| Area | Today | With the observability layer |
|---|---|---|
| Data capture | Paper logs, verbal handoffs, hand-compiled Excel | Automatic, source-level capture from the PLCs |
| Line status | Guessed, or chased down operator by operator | Real-time plant-level rollups and status timelines |
| Downtime & anomalies | Visible long after the shift ends | Logged and visible as they happen |
| The parallel refill stage | Untracked entirely | Monitored — the output-maximizing stage gets data |
| Pipe clogs | Discovered when the line stops; cleared by hand | Pressure precursors tracked, warnings before the hazard |
| History | Scattered notes and memory | A normalized time-series archive for optimization and audits |
| Corporate IT | Disconnected from the floor | Still disconnected — by design, zero production risk |
What it unlocks
This is an architecture engagement — the value is the path it opens. The design follows the classic industrial maturity pattern, deliberately starting where every credible plant-modernization effort starts: by seeing clearly.
Each phase earns the next. No optimization without alerts; no alerts without trustworthy data.
Manual dependencies
Paper logging, verbal handoffs and human-compiled spreadsheets replaced by automatic, source-level capture.
Observability
Factory managers and operators see running outputs, lot consistency and line errors as they happen.
Historical record
Temperature and pressure profiles archived for process optimization and auditing.
Worker safety
The pressure patterns that precede a clog become trackable — the foundation for pre-hazard warnings.
Production risk
Standalone and on-premise — no dependency on, or risk to, live manufacturing or the corporate ERP.
The pattern
Observability unlocked on top of existing PLCs and ERPs — no costly, disruptive replacement of anything that already works.
Why it matters
Industrial environments are full of capable hardware whose data never leaves the floor. The instinct to fix that with a full automation program — or a rip-and-replace ERP project — is exactly what this architecture argues against. A monitoring layer that reads what already exists, respects human interventions, and stays off the corporate network delivers the foundation first, at a fraction of the risk.
The pattern travels. Any manufacturer running PLC-controlled lines with paper logs and end-of-shift spreadsheets — milling, food processing, chemicals, packaging — has a version of the same gap between what its machines know and what its people can see. The same architecture closes it.
Is your plant's data trapped at the edge?
We design real-time monitoring layers on top of existing PLC infrastructure — connecting disconnected line data into central web dashboards without interrupting active production rhythms.