EVERY INGREDIENT, ACCOUNTED FOR
Year
2023
Role
Sole engineer (software)
Status
In production
Stack
Omron PLC · SQL · React Native · React
Silio is full-stack batching management for food and feed manufacturers. It plugs into an existing ERP, drives weighing and blending through an industrial PLC, validates every ingredient that enters a batch, and writes every operator action to a SQL audit log. Operators carry an Android scanner so they can sign off bulk bags where they sit on the floor, without dragging them to a station. The office watches the plant through a live web dashboard. Silio ships as a complete bundle — PLC and remote I/O, load cells, NFC readers, touchscreen HMI panels, rugged Android devices, and the software that ties them together.
The case study below covers an animal-nutrition feed facility in Beaudesert, Queensland that has run on Silio since 2023. The plant previously worked from handwritten work orders and end-of-shift operator signatures. Silio replaced that paper trail with a typed, signed digital workflow across four concurrent production zones. Every weight, every scan, every bag, every action is recorded in real time against the person who did it.
The problem
A feed mill blends dry ingredients into nutritional mixes for livestock. Some ingredients are measured by hand (trace elements, premixes, specific weights of specific flours). Some arrive in bulk bags pre-measured by the supplier and dropped in whole. A single batch can pull 20+ ingredients from both workflows. Traditionally the operator works from a printed work order: weigh each measured ingredient, pick the bulk bags from the warehouse, write it down, sign the sheet at the end. The paperwork gets filed against the batch number. If anyone needs it later, someone walks to the filing cabinet.
This works until it doesn't. Handwritten weights drift from actual weights. Bag counts get off by one. End-of-shift signatures tell you very little about who did what and when. And when an animal gets sick from a specific batch, the chain back through the paperwork is slow and fragile. The customer wanted the traceability the paper trail pretends to give — actually delivered, in real time, for every ingredient in every batch.
The shape of the system
Silio is five pieces of software. An ingestion layer reads work orders from the ERP and feeds them into a 100-order buffer on the PLC. An Omron Sysmac PLC program drives the plant hardware (load cells, valves, motors, scales, and the loss-in-weight silos for the largest dry ingredients) and enforces the weighing and tolerance logic for every ingredient. An Android scanner app runs on rugged devices so operators can scan bulk-bag GINs and sign off with an NFC tap without moving the bag. A SQL backbone captures every operator action — every weight, every scan, every sign-off — as an immutable event. A React dashboard reads SQL live for the office.
The plant runs up to four zones concurrently — each with its own stations, scales, scanners, HMI panels, and operators — and the PLC schedules across all of them. The 100-order buffer is shared. As many as 99 batches can be in flight at once, with up to 99 ingredients each. The dashboard renders every zone side by side.
The ERP owns orders. The PLC is where real-time control lives. SQL is the audit log. The Android app and the dashboard are two windows into the same running system. Every piece has a single job, and the wiring between them is typed and checked at every hop.
The hard bits
Buffering orders between Tencia and the plant
Tencia is the plant's existing ERP — products, recipes, customers, and work orders all live there. Silio doesn't replace it, it reads from it. The ingestion layer pulls orders out in priority order and queues them onto the PLC. The PLC keeps a working buffer of up to 100 active orders, and refills it as orders complete. Up to 99 batches can be in flight at once, with up to 99 ingredients each.
Rush orders are the tricky part. When the office flags an order as urgent, it jumps the queue in Tencia. The ingestion layer picks it up on the next refresh. The PLC promotes it to the top of the working buffer. The relevant station's interface surfaces it immediately. None of this can disrupt whatever's already in progress — you can't yank an in-flight ingredient out of an operator's hand. Silio slots the rush order as the next thing up, not the current thing, and the working buffer makes that safe.
Sometimes the plant has to substitute an ingredient mid-batch — a specific SKU is short, an alternative passes spec, the operator picks it. Silio doesn't pretend that didn't happen. The substitution is recorded against the batch with its own GIN and weight, and the ingestion layer reports it back to Tencia so stock and recipe variance stay accurate. What was planned and what actually happened are both first-class records — never the same row overwritten twice.
The ingestion layer owns the trip back too. When a batch completes, the actual weights and the signed audit trail get written to Tencia so reporting and stock systems stay current. Tencia knows what was planned. Silio reports what actually happened.
Weighing to tolerance, signed by the operator
Weighing is the core of the plant. Each measured ingredient has a target weight and an adjustable tolerance. The PLC reads the scale live and tells the operator's interface when the weight is in tolerance. Only then can the operator accept the ingredient. And only an NFC tap commits it. The tag's UID is the operator's identity.
Dosing isn't a single cutoff — it's a profile. For ingredients that need fine accuracy, the PLC runs a dribble-feed: full speed until close to the target, then a slow trickle to land cleanly inside tolerance without overshoot. Threshold and trickle rate are configurable per ingredient. The largest dry ingredients come from silos sitting on their own load cells — loss-in-weight control, where the discharge is measured as weight lost from the silo rather than weight gained at the scale. Different shape, same audit guarantee.
Four conditions have to agree for a sign-off to commit: the scale is in tolerance, the scanned GIN matches the ingredient the recipe expects next, the GIN is a live stock record in the ERP (not already consumed, not unreceived), and the operator's NFC tag is tapped. The PLC validates all four together. If any one fails — wrong ingredient, weight out of tolerance, stock record stale, unauthorised tag — the sign-off is rejected and nothing hits SQL. The audit log only contains entries where all four conditions agreed at the same moment in time.
This matters because the audit log is the record of who weighed what into which batch. Partial writes, drift between the PLC and SQL, sign-offs without a weight check — any one of those breaks the guarantee. A bag of finished feed shipping to a customer needs to tie unambiguously to a set of NFC-signed events in SQL.
An Android app for the bags you can't carry
Some ingredients arrive in bulk bags that are too big or too awkward to move to a fixed HMI. For those, Silio ships an Android scanner app on rugged devices. The operator carries it to the bag. The app scans the GIN barcode, validates it against the recipe via the PLC, counts bags per GIN (up to five GINs per ingredient, up to five bags per GIN), and signs the ingredient off with an NFC tap. Same sign-off discipline as the fixed station, just portable.
The unusual part is that the app talks to the PLC directly over a raw TCP socket. Fixed-field binary protocol, framed by an STX byte and a 16-bit length prefix. No HTTP, no middleware, no message queue. The PLC's Structured Text UDTs mirror the TypeScript message definitions in the app, so both sides of the wire agree on every byte. Why binary? The PLC doesn't speak HTTP, and a translation layer is just another thing that can fail. A mismatched field is a bug at both design time and runtime. The app can't construct a message the PLC doesn't understand.
The connection stays alive with a heartbeat every five seconds. If the socket dies, the app reconnects with exponential backoff and the PLC's accept loop picks it up. Operators wear gloves and work fast, so the UI is single-screen and state-machine-driven, with audio and vibration feedback on every transition. No chance of landing in an unreachable state. No need to look at the screen to know whether a scan passed.
A dashboard that reads the same truth the floor writes
The office wanted to watch production happen. Which orders are on which stations, who's working them, how far through each batch is, what's queued, what's suspended, and when something goes wrong, what happened and when. The dashboard is the office's window into all of it, accurate within seconds, not minutes.
The dashboard is a React app that reads directly from SQL. The audit log is append-only and events land atomically with every sign-off, which means the dashboard renders live throughput by operator, station, and product without guessing at mid-flight state. A floor manager can click any in-progress order and see every ingredient already signed off — by whom, at what weight, at what time. A query against last Tuesday's production reads the same as a query against this morning's. The dashboard isn't a separate truth. It's a projection of the one that already exists.
The result
Silio has run the Beaudesert plant since 2023. The paper trail is gone. Every gram weighed into every batch — measured or bulk — is recorded in SQL against the operator who handled it and the NFC tap that confirmed it. Tracing a customer complaint back to the batch, then to the ingredients, then to the operators who signed each one, is one query. Not a walk to a filing cabinet.
The ERP stays in charge of orders and reporting. The plant stays in charge of weighing and blending. Silio wires them together so what the ERP plans is what the plant does, and what the plant does is what the ERP reports. The dashboard has become the office's default view of the day — a live feed, not a report run after the fact. And because every commit needs a physical NFC tap, the audit log records human actions, not claims the software made on someone's behalf.