Avoiding Vendor Lock-In in Industrial IoT

Lock-in rarely arrives as a single decision. It accumulates. A gateway vendor ships a closed firmware image, so your data leaves the device only through their cloud. The cloud charges per connected asset, then per message, then per API call. Two years in, the protocol on the wire is documented nowhere, the device certificates are minted by the vendor, and the data model is whatever their portal happens to export. Switching now means re-instrumenting every machine in the field.

The cost shows up in places procurement did not budget for. Per-device royalties that scale with your fleet, not your margin. Firmware you cannot patch when a CVE lands. A roadmap you do not control: when the vendor deprecates a product line or gets acquired, your installed base inherits the decision. None of these are hypothetical. They are the predictable result of letting someone else own the layer between your machines and your business systems.

The single most decisive move is owning the software that runs on the edge device. A gateway built on embedded Linux (a Yocto-based image you can rebuild from source) puts the data-acquisition logic, the protocol parsers, and the upload pipeline under your control. You hold the root credentials. You sign your own firmware. When a field bus changes or a customer asks for a new signal, you edit code and push an OTA update, rather than filing a feature request and waiting for a vendor release.

This is not a call for a from-scratch build. The pieces are mature and open: the Linux kernel, a CAN stack via SocketCAN, libmodbus for serial and TCP Modbus, an MQTT client such as Eclipse Mosquitto for the uplink. What matters is that the integration is yours, version-controlled in your own repository, and reproducible without a phone call to anyone. A system you can rebuild is a system you can move.

Interoperability is decided at the protocol boundary. On the machine side, the field buses are already standards: J1939 over CAN on a drivetrain or hydraulic system, Modbus RTU on an auxiliary pump or VFD, OPC-UA where a modern PLC exposes a structured address space. Read those directly. The moment you accept a vendor-specific binary protocol in between, you have handed them the translation layer, and the translation layer is the lock.

The uplink deserves the same discipline. MQTT with store-and-forward buffering moves telemetry to any broker that speaks the protocol, your own Mosquitto cluster today, a managed broker tomorrow, with the device none the wiser. Keep the payload in an open, documented schema (JSON or a published Protobuf definition) so a second consumer can read it without reverse-engineering. When every interface on the path is a published standard, replacing a component is a configuration change, not a project.

Technical openness means little if the paperwork assigns the work product to the vendor. For an OEM shipping connected equipment, the embedded software is part of the product, and the contract should say so: source code, build scripts, hardware schematics, and signing keys delivered to you, with a licence that lets you modify and redistribute inside your product. Anything less leaves a dependency that no architecture diagram can remove.

Ownership also changes the economics. When the gateway code is yours, there is no per-asset licence that grows with the fleet and no per-feature upsell gate between you and your own roadmap. You can fork it for a new product line, hand it to a different integrator, or bring it fully in-house. The asset on your balance sheet is the system, not a revocable right to use someone else's.

A vendor-neutral architecture is modular on purpose, with clean seams between acquisition, transport, storage, and presentation. The gateway should not care which broker it talks to. The broker should not care which database subscribes. The database should not care which dashboard queries it. Each boundary is a published interface, so a change on one side does not cascade through the rest.

That separation is what makes migration survivable. Replace the time-series store and the gateways keep publishing. Move from one cloud to another and the field devices never notice, because they target a hostname and a topic, not a proprietary endpoint. The discipline costs a little more design effort at the start. It buys you the option to change your mind for the life of the deployment, which on industrial hardware is measured in a decade, not a release cycle.

Put the pieces together and the result is unremarkable, which is the point: open Linux gateways you control, standard field protocols read directly, MQTT to an open broker, an open time-series database, and a dashboard layer that talks to documented APIs. No single component is irreplaceable, and the data model is yours from sensor to query. That is a system you can operate, extend, and migrate on your own terms.

This is the approach Melqart Systems builds to. We deliver open systems, not proprietary black boxes, and every engagement ends with the source code, the schematics, and the credentials in your hands. Explore vendor-neutral routers & gateways and secure remote access for OT.