A PLC connection that streams raw register values with no naming convention isn't integration — it's a pipe with no address book on either end. iFactory, an on-premise AI platform for automotive smart factory programs, builds the tag namespace and event-stream structure first, before a single dashboard gets built on top of it. See how the namespace gets designed.
Connected Isn't The Same As Structured
A live OPC-UA feed with no tag namespace is just a faster way to get the wrong data to the wrong system.
Tag Mapping Isn't The Hard Part. Naming It Consistently Is.
Connecting to a PLC is a protocol problem. Making the data mean the same thing everywhere downstream is a naming problem, and it's the one most integrations never solve.
- Line 1 names a tag "Sta12_Temp" → Line 2 names the same reading "WeldTempC4" → one AI model can't use both without a translation layer someone forgot to build.
- A controller gets replaced → the new PLC vendor's native tag names don't match the old ones → every downstream dashboard and model silently breaks.
A namespace pattern — asset, line, area, site, in a fixed order — fixes this once instead of per-integration. It's boring work. It's also the reason some plants scale their AI pilot to 40 lines and others get stuck rebuilding the same mapping four times.
One Naming Order, Applied Everywhere, No Exceptions
| Level | Example | Why it's fixed at this position |
|---|---|---|
| Site | plant-pune | Multi-site rollups need this first or nothing aggregates cleanly |
| Area | body-shop | Groups lines that share a process type and failure patterns |
| Line | line-04 | Matches how operations already talks about the floor |
| Asset | robot-weld-12 | The actual tag source — never skipped, never abbreviated differently twice |
| Signal | torque-actual | Plain engineering name, same unit and type every time it appears |
Every tag becomes plant-pune.body-shop.line-04.robot-weld-12.torque-actual — readable by a person, parseable by a machine, identical in structure whether it came from an Allen-Bradley controller or a Siemens one.
Still Naming Tags Differently Line To Line?
Send a sample of your current tag list — the team will show what a consistent namespace would look like across it before any integration work starts.
If You're Polling Every Five Seconds, You Don't Have Real-Time Data
A decision that needs to fire in 200 milliseconds can't be built on a system that checks the PLC every five seconds.
- Polling → asks the PLC "anything changed?" on a fixed timer, whether or not anything happened.
- Event streaming → the PLC or edge gateway pushes a change the instant it happens, timestamped at the source.
Polling intervals get tuned down to "good enough" and stay there, because tightening them floods the network with repeat values. An event-driven model publishes once per actual change — a part present, a torque reading out of band, a cycle complete — which is both lighter on the network and faster to a decision.
Not Every Decision Needs The Same Speed
Architecting every tag for sub-second delivery wastes bandwidth on signals nobody needs that fast. Architecting everything for a five-minute rollup makes quality holds useless. The event-stream design has to classify each tag by decision latency before the pipeline is built, not after something gets missed.
The Tag Existed. The Timing Didn't.
A body-shop weld cell has a torque-feedback tag wired in and historian-logged — on paper, fully integrated. The polling interval was set to 10 seconds during initial commissioning, two years earlier, to keep the historian load manageable. A gun starts drifting out of torque spec mid-shift; the drift self-corrects within the 10-second polling window three times before a reading finally lands outside tolerance. By then eleven bad welds have gone down the line. The tag was there. The integration was real. The event never got caught in time, because nobody had classified torque drift as a sub-second decision when the pipeline was designed.
Five Questions That Belong In The Design Phase, Not After Go-Live
- What's the naming order, and is it written down? If it lives in one engineer's head, it isn't a standard yet.
- Which tags are event-driven and which are polled? Not every signal needs push delivery — deciding which do is the actual design work.
- What's the latency budget per decision type? Safety, quality, and scheduling each need a different answer.
- Does a controller swap break the namespace? If vendor-native tag names leak into downstream systems, it will.
- Who owns the namespace once it's live? A pattern with no owner drifts back to ad hoc within a year.
The Namespace That Worked On Line 1 Breaks By Line 6
A naming pattern invented under deadline pressure for the pilot line rarely survives contact with the fifth or sixth line that joins later.
- Pilot line uses a shortcut → "ST12" instead of the full site-area-line-asset path → fine with one line, unreadable once ten lines each have their own "ST12."
- New line onboards under time pressure → engineer copies the nearest existing tag list instead of the documented pattern → two slightly different namespaces now coexist.
The fix isn't more documentation after the fact — it's treating the namespace as a reviewed standard from line one, with someone responsible for rejecting shortcuts before they ship, not cleaning them up two years later across forty lines.
Namespace And Event Classification Come Before The Dashboard
iFactory's integration team maps the controller layer first — asset by asset, signal by signal — and assigns every tag a namespace position and a latency class before any model training or dashboard work begins.
- Fixed site-area-line-asset-signal namespace, applied the same way regardless of PLC vendor.
- OPC-UA and MQTT event publishing for time-critical tags; scheduled polling retained only where latency doesn't matter.
- Vendor-agnostic translation layer, so a controller swap doesn't break downstream naming.
- On-premise processing — tag data and event streams stay inside the plant network.
What An Automation Engineer Should Check Before Signing Off
A PLC-SCADA integration is ready for AI workloads when every tag has a namespace position and a documented latency class — not just a live connection.
What Automotive Plant Teams Ask About PLC-SCADA Namespace Design
If different lines or systems name the same signal differently, yes — the connection works but the data won't scale across more lines or models. Walk through your current tag list with the team.
A live connection polled too slowly for the decision it's supporting will miss the event entirely, as it did with the torque-drift example above. Check your current polling intervals against decision latency.
No — classify tags by how fast a decision needs to happen; scheduling and OEE rollups are fine on a slower poll. Ask support how tags get classified.
A vendor-agnostic translation layer keeps the namespace stable even when the underlying controller's native tag names change. See how the translation layer works.
A named owner — usually plant automation or controls engineering — keeps it from drifting back to ad hoc naming within the first year. Talk through ownership with the integration team.
Design Your Tag Namespace Before The Next Line Onboards
Book a session with the iFactory team and map your controller layer into a namespace and event-stream pattern that scales past the first line.
