Industrial Dashboard: Build vs Buy for System Integrators
Every system integrator faces this question eventually. Your client needs a dashboard. They want to see temperatures, pressures, flow rates, motor status — all the usual suspects from their PLCs and RTUs. The data exists on Modbus registers. The question is how to get it onto a screen.
Do you build it? Grafana for visualization, InfluxDB for storage, Mosquitto for MQTT transport, Telegraf or a custom script for polling. Docker Compose to glue the pieces together. It works. You have done it before.
Or do you buy something that works out of the box? One piece of software. One config file. Protocol drivers built in. Dashboards you can edit in the browser. Support when something breaks. Either way, applying sound industrial dashboard design principles will determine whether operators actually use what you build or deploy.
This is not an abstract question. It is a margin question. Every hour you spend building and maintaining a dashboard stack is an hour you are not billing to the next project. Let us look at the numbers.
The Build Path
Here is what integrators typically cobble together when they build an industrial IoT dashboard from open-source components:
- Grafana for visualization. Panels, graphs, gauges, alerts. The UI is powerful but opinionated. Getting it to look like an industrial HMI takes custom plugins and CSS overrides.
- InfluxDB for time-series storage. It absorbs sensor data well. But you are now managing a database — retention policies, disk usage, backup strategies, version upgrades.
- Mosquitto as the MQTT broker. Routes messages between Telegraf, custom collectors, and whatever else you plug in. Another process to monitor, another config to maintain.
- Telegraf or a custom collector for Modbus polling. Telegraf has a Modbus input plugin. It works for simple cases. For anything non-trivial — custom register maps, byte-swapping, multi-word values — you end up writing Python scripts.
- Nginx as a reverse proxy. TLS termination, basic auth, routing Grafana's web interface to port 443. Yet another config file, yet another service to keep running.
- Docker Compose to glue it all together. Because installing Grafana, InfluxDB, Mosquitto, Telegraf, and Nginx natively on the same machine is a dependency nightmare. Containers solve that. They also add a container runtime to manage.
That is four to six components, each with its own version, config file, log output, and failure mode. Total resource footprint: 1-2 GB RAM minimum before you ingest a single data point. And that is on a good day. For a lightweight SCADA software alternative that replaces all of these with a single binary, the contrast is stark.
The build path works. People do it every day. The question is whether it is the best use of your time.
The Buy Path
The alternative is a single piece of software that does all of the above:
- One process instead of five. Data acquisition, storage, visualization, alerting — all in one binary.
- One config file. Define your Modbus devices, polling intervals, dashboard layout, and alert thresholds in a single YAML file. No cross-service configuration.
- Built-in protocol drivers. Modbus TCP, MQTT, OPC-UA — no plugins, no scripts, no custom collectors. Configure the register map and go.
- Browser-based dashboard editor. Drag, drop, configure. No Grafana plugin wrangling. No JSON panel definitions copied from Stack Overflow.
- Support when things break. A vendor who answers email. A changelog. Documentation that was written for integrators, not Kubernetes administrators.
The buy path is not magic. It is software built by people who had the same problem you do, solved it, and productized the solution. The question is whether the price is worth the time you save. Understanding the underlying SCADA architecture helps you evaluate whether a single-binary approach fits your deployment needs.
Side-by-Side Comparison
Read that last two rows again. The "free" option costs 40-144 hours of your time over three years. What is your hourly rate? $50? $100? $150? At $100/hour, the build path costs $4,000-$14,400 in labor alone over three years. The buy path costs $249 once.
The Real Cost of Building
The sticker price of open-source software is zero. The real price is your time. Here is where it goes.
Development Time: 20-40 Hours for the First Setup
Nobody sits down and builds a Grafana stack in two hours on their first try. You install Docker. You pull images. You write a docker-compose.yml. You realize the Telegraf Modbus plugin does not support your register layout. You write a Python script instead. You fight with InfluxDB's query syntax. You spend three hours getting Grafana to show the right gauge range. You configure Nginx for HTTPS.
Twenty hours is optimistic. Forty is realistic for a production-grade setup with proper auth, backups, and alerting.
Each New Deployment: 4-8 Hours of Tweaking
The second client is faster. You have templates. But every site is different — different PLC models, different register maps, different network topologies. You adapt the Docker Compose file. You rewrite the Telegraf config. You rebuild the Grafana dashboards because the sensor list changed.
Four hours per deployment if you have good templates. Eight hours if the site has quirks. Industrial sites always have quirks.
Maintenance: 2-4 Hours Per Month Per Deployment
This is the cost nobody accounts for. Every month, something needs attention:
- InfluxDB disk usage creeping up — adjust retention policies
- Docker image updates — test before applying, pray nothing breaks
- Certificate renewal for HTTPS
- Mosquitto connection drops after a network glitch — restart and investigate
- Client wants a new sensor on the dashboard — edit config, restart Telegraf, update Grafana panel
Two hours per month if everything goes smoothly. Four hours when it does not. Over a year, that is 24-48 hours per deployment. Over three years, 72-144 hours.
Opportunity Cost
Every hour you spend maintaining a Grafana stack is an hour you are not selling a new project, quoting a new client, or deploying a new site. If your billing rate is $100/hour and you spend 40 hours building a dashboard, that dashboard cost you $4,000 in revenue. You just built the most expensive free dashboard in history.
Skill Requirements
The build path demands breadth. You need to know:
- Docker and container networking
- Grafana panel configuration and templating
- InfluxDB data model and Flux/InfluxQL queries
- MQTT topic design and broker configuration
- Modbus register mapping and byte-order handling
- Linux system administration (systemd, nginx, TLS)
That is a full-stack skill set. If you have it, great. If you are a system integrator who specializes in PLC programming and field wiring, you are now also a DevOps engineer. Whether you wanted to be or not.
When Building Makes Sense
To be clear, building your own dashboard stack is not always the wrong call. Here is when it makes sense:
- You already have the expertise and templates. You have built ten Grafana stacks. You have a repository of Docker Compose files, Telegraf configs, and Grafana dashboard JSON that you can copy-paste. The marginal cost of the next deployment is low.
- The client needs something truly custom. 3D visualizations. AR overlays on live camera feeds. Predictive maintenance with ML models trained on their data. If the requirement goes beyond gauges and trend charts, off-the-shelf software will not cut it.
- You are building a product, not a project. If your business model is to build a custom monitoring platform and sell it to 100 clients, the upfront investment in a Grafana-based stack might make sense. You are a software company now. Act like one.
- Budget is the only constraint and you have free time. The client has zero budget for software. You have unused capacity between projects. Build it, deploy it, move on. Just remember that the maintenance cost does not go away.
These are legitimate reasons. But they apply to a small minority of system integrators. Most integrators are in the business of deploying projects, not maintaining software platforms.
When Buying Is the Obvious Choice
For most system integrators, the buy path wins. Here is why:
- You are a system integrator, not a software developer. Your value is understanding the plant, wiring the sensors, programming the PLCs, and commissioning the system. Your value is not configuring InfluxDB retention policies at midnight because the disk filled up.
- You have multiple clients with similar needs. Every client wants to see their data. The dashboards look different but the underlying pattern is the same: poll Modbus, store values, display gauges, send alerts. This is a solved problem. Stop solving it.
- Speed of deployment matters. The client wants it running this week, not next month. With a single binary, you deploy in five minutes. With a Grafana stack, you are still debugging Docker networking on day two.
- You do not want to maintain custom software for the next five years. Industrial projects have long tails. The client expects the system to work for years. They will call you when it breaks. If "it" is five Docker containers, that phone call is going to be long and expensive.
- You want to keep the margin. When you buy software for $249 and bill the client $2,000-$5,000 for the dashboard portion of the project, your margin is 85-95%. When you build it yourself, your margin is whatever is left after subtracting 40 hours of unbillable setup time.
The buy path is not about being lazy. It is about being strategic. You should buy the commodity parts and save your effort for the parts that differentiate you — the site-specific engineering, the control logic, the commissioning, the relationship with the client.
One Binary. The Entire Stack.
Voltrus replaces Grafana, InfluxDB, Mosquitto, Telegraf, and Nginx with a single binary. Built-in Modbus, MQTT, OPC-UA drivers. Browser-based dashboard editor. Alerting. All for $249 lifetime per deployment.
Deploy in 5 MinutesFrequently Asked Questions
Should I build or buy an industrial dashboard?
For most system integrators, buying is the better choice. Building a Grafana + InfluxDB + Mosquitto + Telegraf stack takes 20-40 hours for initial setup, 4-8 hours per new deployment, and 2-4 hours per month per deployment in maintenance. At $100/hour, that is $4,000-$14,400 in labor over three years. Buying off-the-shelf SCADA software costs $249 once for a lifetime license with built-in protocol drivers, dashboards, and alerting.
How much does it cost to build a Grafana industrial dashboard?
The software is free (open source), but the labor cost is significant: 20-40 hours for initial setup ($2,000-$4,000 at $100/hr), 4-8 hours per additional deployment, and 24-48 hours per year per deployment in ongoing maintenance. Over three years, a single deployment costs $4,000-$14,400 in labor. This does not include the cost of learning Docker, InfluxDB, Grafana templating, and MQTT broker configuration.
What components do I need to build an industrial IoT dashboard?
A typical build stack includes Grafana for visualization, InfluxDB for time-series storage, Mosquitto as an MQTT broker, Telegraf or custom scripts for Modbus polling, Nginx as a reverse proxy for TLS, and Docker Compose to manage everything. That is 5-6 services with separate config files, log outputs, and failure modes, requiring 1-2 GB RAM minimum before ingesting data.
When does building your own dashboard make sense?
Building makes sense when you already have expertise and reusable templates from 10+ previous deployments, the client needs something truly custom (3D visualizations, ML models, AR overlays), you are building a product to sell to many clients rather than a single project, or the client has zero software budget and you have free time between projects.
How much RAM does an industrial monitoring dashboard need?
A Grafana + InfluxDB + Mosquitto + Telegraf + Nginx stack requires 1-2 GB RAM minimum before ingesting any data points, because each service runs its own process with its own memory footprint. A single-binary SCADA solution like Voltrus uses less than 50 MB RAM for the same functionality because all components share one process.