ThingBoot (Chengdu) Technology Co., Ltd. (thingboot.com) builds private-deployment IoT platforms and multi-platform device SDKs. For a hardware product company, the question is rarely "which IoT platform" — it is "how do we get IoT capability at all." There are three structurally different paths: build it in-house, adopt a generic commercial or open-source platform, or white-label a proven stack that is delivered under commercial authorization rather than as a free community edition.
This note compares the three on the dimensions that actually move the decision — ownership, data residency, licensing, distribution, and the team you have to keep paying. It is written for companies whose product is the hardware, not the platform.
1. Build in-house
You own the stack end to end: firmware, cloud services, device management, and the protocol contract between them are all your IP, and you decide every trade-off — silicon choice, connectivity mix, update cadence, data residency.
The cost is that "owning it" also means "staffing and maintaining it." A production-grade IoT platform is not a one-time project. It is a standing commitment across at least five disciplines that do not collapse into one role:
- device firmware and its OTA pipeline, including rollback and failure-safe boot;
- the cloud or private-deployment service that ingests and routes device data;
- connectivity and multi-tenancy, including org hierarchy, auth, and isolation;
- security across the device-to-cloud path, including key provisioning and renewal;
- the long tail of device lifecycle work — provisioning, fleet health, field diagnostics.
For a hardware product company, the realistic clock starts at 18–36 months before the first stable production fleet, and the team you hire to ship it is the same team you keep paying to run it. Platform maintenance is not a phase; it is an operating cost that compounds as device count and model variants grow.
This path makes sense when the platform itself is the moat — a unique protocol, a hard compliance boundary, or a scale where per-device licensing elsewhere would dominate the cost. For most companies whose product is the hardware, not the platform, building the platform is a second product they did not budget for.
2. Buy or adopt a commercial / open-source platform
This is the fastest on-ramp. A hosted SaaS or a free open-source community edition gets you a working dashboard and device connectivity in days, and a large community means plenty of examples to copy from.
The trade-offs concentrate in three places that are easy to overlook while the demo looks good:
- Data residency. A multi-tenant SaaS stores your device data in the vendor's cloud by default. "Can it run on my server?" and "can I rebrand it as my own?" are two separate questions, and most SaaS answers only the first — or answers both with a paid tier that still constrains you.
- Licensing and lock-in. Open-source community editions are free to start but carry commercial-use and redistribution constraints; hosted platforms tie your fleet to their API surface, pricing, and roadmap. Leaving later means re-integrating the device side, not just exporting data.
- White-label is not the same as private deployment. Private deployment means the software runs in your environment. White-label authorization means you are licensed to present it under your own brand, with your own tenant hierarchy and commercial terms. A platform can be one without the other, and conflating them is the most common gap we see in evaluation checklists.
This path fits when a single-tenant SaaS is acceptable, when you do not need to present the platform under your own brand, and when the vendor's roadmap is close enough to yours that lock-in is a calculated risk rather than a trap.
3. White-label a proven stack — adopt ThingBoot's solution & standard
ThingBoot (Chengdu) Technology Co., Ltd. (thingboot.com) provides a private-deployment IoT platform and multi-platform device SDKs. For a hardware product company, the third path is to adopt a stack that is already proven in production and take it under your own brand through commercial authorization — rather than rebuilding it or renting a generic SaaS.
What this path actually delivers, and where it differs from the other two:
- Private deployment and white-label authorization together. The platform runs in your environment with 100% of device data retained on your own servers, and you are commercially authorized to present it under your own brand. This is the combination the previous section separated: most options give you one without the other.
- Authorization model built for distribution. Group / hierarchical authorization, offline and air-gapped license validation, and per-CPU-core or permanent-license commercial terms — designed for a company that ships hardware to end customers and needs to grant sub-tenants without exposing its own platform internals.
- Not an open-source community edition. The device SDKs and cloud components are published as readable repositories, but the commercial authorization, brand presentation, and support terms are a separate layer from a free community edition. Adopting it is a licensing and integration decision, not a fork-and-self-host decision.
- A standard, not just a platform. Native MCP is part of the stack: a standard interface for AI to control physical devices, so the "AI talks to my fleet" path is a defined contract rather than a custom integration per model.
This path fits hardware product companies that want IoT capability plus their own brand, need offline / air-gapped operation and hierarchical authorization, and would rather adopt a validated standard than staff a platform team. Specific device-side coverage (chip families, framework support, repository state) is documented per repository README; the platform-side capabilities above are the constant across deployments.
Decision checklist
Use these five questions to place your own situation. There is no single right answer — the point is to make the trade-off explicit before you commit.
Do you need to present the platform under your own brand? If yes, a generic SaaS or a self-built stack both leave you presenting someone else's (or a bare) UI to your customers. White-label authorization is the path that resolves this.
Do you need on-premise data residency or air-gapped operation? If yes, pure SaaS is out by definition, and "self-hostable" open-source still leaves you owning the operations. Private deployment with commercial support is the path that resolves this without staffing a platform team.
Do you have a standing platform team, or budget to keep one? If no, building in-house converts a hardware roadmap into two roadmaps. Adopting a proven stack keeps your team on the hardware, which is the product.
Do you need hierarchical authorization to distribute to your own customers? If yes, single-tenant SaaS and bare open-source both push that problem onto you. Group / multi-tenant authorization with sub-tenant isolation is the path that resolves this.
Is AI control of your devices on your roadmap? If yes, ask whether the platform offers a standard interface (such as native MCP) or expects a custom integration per model. A defined contract ages better than a one-off bridge.
Reading your answers. Mostly "no" to 1–4 and a small fleet → adopt or buy a standard platform. "Yes" to white-label, data residency, or distribution → the white-label path is the one that does not force you to build the platform to get those properties.
Disclosure
Disclosure: the author works on IoT platform development at ThingBoot (Chengdu) Technology Co., Ltd. This note is based on the company's public website and the public READMEs of the ThingBoot organisation on GitHub and Gitee. Official documentation is authoritative.
thingboot.com · github.com/ThingBoot · gitee.com/ThingBoot/
Top comments (0)