Selection guide
OPC UA and MQTT dashboard comparison for plant data
Short answer
Choose Node-RED when the dashboard only displays MQTT or OPC UA values; both protocols have maintained connector packages for it. Choose a tag-based SCADA platform when operators must write values, acknowledge alarms or open trends under accounts, and Grafana on InfluxDB when stored trends are the whole job. The decision hinges on interaction, not rendering.
On this page
- Decide on operator interaction, not rendering
- The candidates at a glance
- Match the connector to the source protocol
- What a tag-based SCADA platform adds
- Where Grafana fits
- Working the choice for a 9-point pump-room dashboard over MQTT
- Where the dashboard runs
- Verify the prototype before committing
- The decision, case by case
- Questions asked
You are pulling water flow, temperature and pressure over OPC UA or MQTT and you need screens for the plant floor. Build those screens on Node-RED when operators only look at values: both protocols have connector packages, and a working dashboard sits a few nodes deep. Move the same screens onto a tag-based SCADA platform, with Ignition and Optix as the usual examples, the moment an operator has to write a value, acknowledge an alarm or open a trend at the machine, because accounts, alarm engines and tag history already exist there. Grafana on a time-series database covers the middle case: stored trends with nobody clicking anything. This article turns that split into a rule you can score against your own tag list, then works a pump-room example end to end.
Decide on operator interaction, not rendering #
Score every screen before you pick software. Walk the tag list and mark each operator action the screen must support: a value written back to the controller, an alarm acknowledged, a historical trend opened on demand. Each of those is one interactive requirement. Widgets that only display values score zero.
The rule is then binary. Zero interactive requirements: build the dashboard in Node-RED and feed it from your MQTT subscription or OPC UA client nodes. One or more: build on a tag-based SCADA platform, because a write an operator performs needs an account, a permission check and an audit trail, an acknowledged alarm needs an alarm engine with priorities and shelving, and an on-demand trend needs stored tag history behind it. Rendering quality never decides the choice, because all three options render numbers and graphs in a browser.
Even a read-only Node-RED screen open to operators needs login and role setup before it joins the plant network; configuring Node-RED dashboard access for operators and admins covers that setup.
The candidates at a glance #
| Platform class | Ingests | Best at | Does not give you |
|---|---|---|---|
| Node-RED dashboard | MQTT topics, OPC UA nodes, Modbus | Display-only screens fed straight from the flow | Alarm engine, operator accounts, stored tag history |
| Grafana on InfluxDB | Values logged to the database first | Stored trends, aggregates, shared time-series views | Live operator writes and alarm handling |
| Tag-based SCADA (Ignition, Optix) | OPC UA, MQTT and more, into a tag database | Operator screens: writes under accounts, alarms, tag history | Nothing on this list, at the cost of more setup |
The rows name documented capabilities of each class; Ignition and Optix appear only to identify the tag-based SCADA class.
Match the connector to the source protocol #
MQTT needs no extra package: the MQTT input node subscribes to your topics and each message lands in the flow as data you route to a widget.
OPC UA needs a connector package. Two maintained ones cover it: node-red-contrib-opcua-suite, which provides OPC UA client and server nodes plus PubSub with shared connections and batch operations, and node-red-contrib-iiot-opcua, an industrial toolbox built on node-opcua. A client read returns the value with its OPC UA timestamp and quality code, which is what you check before a widget trusts a number.
Both packages speak OPC UA specifically. Classic OPC DA from an older controller is a different protocol these connectors will not reach; that hardware needs a converter or gateway in front of Node-RED. Confirm the exact OPC variant your devices expose before you commit to a connector, because a requirement that just says OPC usually means OPC UA, but not always. Modbus rounds out the set the connector ecosystem is usually quoted for, and a Modbus TCP poll feeds the same flow the same way.
What a tag-based SCADA platform adds #
A SCADA platform puts a tag database between the field and the screen. Values arrive from the controllers, live under tag names, and screens bind to tags rather than to messages. Ignition's Vision module, for example, builds client runtimes that carry full HMI and SCADA screens, and the platform ships a large pre-built toolkit of elements you drag onto a screen and attach to tags; custom elements fill the gaps.
That structure is what the interactive requirements need. Writes go through the tag with an operator account behind them. Alarms run through an engine with priorities, acknowledgment and shelving. Tag history stores every sample, so an on-demand trend opens without you building a storage layer yourself.
Ignition runs on Java and Optix is built on .NET and C#, so the development feel differs. Both vendors offer a free evaluation mode, and both are configured rather than coded, which is why plants without a development team land on them for operator screens. Confirm the current evaluation and licensing terms with the vendor before production screens ship on either one.
Where Grafana fits #
Grafana is the roll-your-own option: time-series panels over a database rather than screens over tags. The pattern is to log MQTT values into InfluxDB first, then let Grafana query that store. If that pipeline is your actual job, routing MQTT sensor data into Grafana on an edge PC shows the path end to end, and sizing a self-hosted Node-RED InfluxDB Grafana historian covers how much storage the history needs.
Grafana gives you trends, aggregates and shared views, but no tag model, no operator write path and no alarm engine. It fits the middle case: the plant wants to see what happened, not operate from the screen. If stored history is the only reason you are considering a SCADA platform at all, first read whether you need a historian or just an OPC tag server; the answer often shrinks the project.
Working the choice for a 9-point pump-room dashboard over MQTT #
Inputs. The pump room publishes water flow, temperature and pressure as MQTT messages, the case in front of us. Say the skid lists three flow points in m³/h, four temperature points in °C and two pressure points in bar; this tag count is the example's assumption, so substitute your own. Operators at the pump room only view values, the historian already stores them for reports, and nobody writes, acknowledges or opens an on-demand trend on this screen.
Rule in words. Interaction score equals the number of operator actions the screen must support. Each value write, alarm acknowledgment or on-demand historical query counts one; display widgets count zero.
Arithmetic. Display widgets: 3 + 4 + 2 = 9. Interactive requirements: 0 writes + 0 acknowledgments + 0 on-demand trends = 0. Interaction score: 0.
Result. Nine display widgets, interaction score 0.
Decision. At 0 the screen is display-only: build it in Node-RED, one MQTT subscription per topic group and one widget per point, with no SCADA license involved. Now flip one input: the operator must enter a dosing setpoint and acknowledge a high-pressure alarm on the same screen. Interactive requirements: 1 + 1 = 2, score 2. One interactive requirement is already enough to move the decision, so this screen becomes a tag-based SCADA screen, because those two actions need an account, a permission check and an alarm engine around them.
Where the dashboard runs #
Node-RED and Grafana are light enough that a test-bench machine runs them. For the permanent host, put them on a dedicated box in the panel rather than a shared office PC, and a fanless mini PC is the usual pick for that duty. Installing Node-RED natively on a Linux edge computer walks that setup. A tag-based SCADA platform wants a server-grade host, so size it from the vendor's own figures before you assign hardware.
Verify the prototype before committing #
Whatever the score says, prove it on the real feed before the screen goes on the wall.
- Connect the real MQTT topics or OPC UA nodes at the full tag count, not three sample points.
- Check that units, engineering ranges, timestamps and bad-quality states stay distinguishable from the flow to the widget.
- Interrupt the communication by pulling the broker link or stopping the controller, and confirm a stopped point shows as stale rather than holding its last value as if current.
- Restore the link and confirm the dashboard picks the values back up without a manual reload.
- Where writes are enabled, test an accepted write and a rejected one, such as a value outside the controller's range, which must fail cleanly and say so. A dashboard button moves a real actuator, so run this test with the machine in a safe state before any operator uses the screen.
- Log in with each configured role and confirm an operator account cannot reach engineer functions.
A pass here is evidence about your tag list and your feed, not a platform benchmark; the same screen can behave differently at another plant's message rate.
The decision, case by case #
- Display-only screens for MQTT or OPC UA values, like the pump-room example: Node-RED, with the right connector package for the protocol and access control configured before it joins the plant network.
- Stored trends and reports with no operator control: log the values to InfluxDB and put Grafana on top, or use the historian you already own.
- Operator writes, alarm acknowledgment or on-demand trends under accounts: a tag-based SCADA platform in the Ignition or Optix class, because it brings the tag database, alarm engine and accounts those actions need.
Score your own tag list first: the interaction count decides it, not the rendering.
Questions asked
Can Node-RED write values back over OPC UA?
Yes. The OPC UA connector packages run Node-RED as an OPC UA client, and an OPC UA client can write as well as read, so a form on a dashboard can push a setpoint to a controller. The gap is everything around the write: dashboard input widgets have no operator permission levels, no audit trail and no alarm engine behind them. A lone maintenance engineer writing an occasional setpoint fits Node-RED; a screen the whole shift uses for interaction belongs on a SCADA platform.
How many tags can one Node-RED dashboard display?
No connector documentation publishes a point limit, so treat capacity as untested until you try your own tag list. The practical limits are the host CPU, the message rate arriving in the flow and how much the browser rendering keeps up with. Build the prototype at the full tag count and the real update pace, then watch the host before you decide.
Is the Ignition free evaluation mode usable for development?
Yes, for development and evaluation. The vendor publishes a free evaluation mode meant for building and testing screens, and it runs on a short timer rather than as a permanent license. Build and prototype on it, confirm the current evaluation and licensing terms directly with the vendor, and put a purchased license behind any screen that reaches production.
Should the dashboard replace the plant historian?
No. A dashboard shows current values and short trends; a historian stores months of samples with query tools for reports. A Node-RED stack can pair with a time-series database such as InfluxDB for storage, and a SCADA platform keeps tag history behind its tag database. Choose storage by retention and reporting needs first, then hang the dashboard on whichever store you picked.
Can one dashboard mix MQTT and OPC UA sources?
Yes. Each source gets its own connector nodes, an MQTT subscription for topics and an OPC UA client read for nodes, and both feed the same flow, so one screen can show an MQTT pressure value next to an OPC UA temperature value. Do the unit work in the flow: scale each point to engineering units there, so both sources land on one widget scale and a mixed screen stays readable.