ThingIO

Plane: Data Plane

Purpose

IoT data processing, analytics, and dashboard visualization. ThingIO is the platform service that gives developers and operators the tools to process device telemetry, build dashboards, and create visual widgets — all scoped to the devices enrolled in their account.

ThingIO is built on Apache StreamPipes. It provides the data processing and visualization capabilities that DeviceAdmin deliberately excludes — complex analytics, custom dashboards, and data pipeline management.

Responsibilities

• Provide data processing pipelines for device telemetry (scoped per account)

• Offer REST APIs for dashboard and widget management

• Provide a React component library (SDK) for embedding dashboards and widgets into applications

• Enable applications to register custom dashboards and visual widgets

• Support data sourcing from enrolled device telemetry

• Provide data sinking to external systems (databases, webhooks, notifications)

How ThingIO Relates to Other Services

                    ┌─────────────┐
                    │ Applications │
                    │ (WES, CJ)   │
                    └──────┬──────┘
                           │ embed widgets via
                           │ React SDK + APIs
                           ▼
┌──────────────┐    ┌─────────────┐    ┌──────────────┐
│  DeviceAdmin  │───►│   ThingIO   │◄───│   OTAForge   │
│  (devices,    │    │             │    │  (OTA stats   │
│   alerts)     │    │ Processing  │    │   as data     │
└──────────────┘    │ APIs + SDK  │    │   source)     │
                    └──────┬──────┘    └──────────────┘
                           │ reads telemetry
                           ▼
                    ┌─────────────┐
                    │ StreamPipes  │
                    │ (via Kafka)  │
                    └─────────────┘

• DeviceAdmin handles device enrollment and basic alerts

• ThingIO handles data processing and visualization (APIs + React SDK)

• OTAForge handles artifact distribution

Account Scoping

All ThingIO resources are scoped to the account that creates them. An account can only process telemetry from devices enrolled under that account (as registered in DeviceAdmin).

Resource	Scope	Visibility
Data pipeline	Account	Only processes telemetry from account’s devices
Dashboard	Account	Visible to account members only
Widget	Account (shareable)	Can be published to Marketplace as a component
Data source	Account	Bound to account’s enrolled devices
Data sink	Account	Configured per account (webhooks, databases)

React SDK

ThingIO does not provide a standalone dashboard web application. Instead, it provides:

1. REST APIs for managing dashboards, widgets, pipelines, and data sources/sinks

2. React component library (@flexgalaxy/thingIO-widgets) for embedding dashboards and widgets into any application

Applications (WES, ClearJanitor, StarGate, or third-party apps) use the React SDK to embed ThingIO visualizations directly into their own UIs.

Why React SDK (not a standalone app)

Approach	Why Not
Standalone web app	Forces context-switching; can’t integrate with app-specific workflows
iframe embedding	Poor UX, cross-origin issues, no shared state with host app
Redirect to ThingIO	Users lose application context
React SDK (chosen)	Widgets render natively inside the host app, share auth context, and respond to app-specific events

SDK Usage

import { DashboardView, BatteryGauge, CoverageHeatmap }
  from '@flexgalaxy/thingIO-widgets';

// Embed a full dashboard
<DashboardView dashboardId="fleet-overview" />

// Embed individual widgets
<BatteryGauge deviceTypes={['amr']} aggregation="min" />
<CoverageHeatmap deviceTypes={['cleaning_robot']} timeWindow="current_shift" />

The SDK handles authentication (passes the host app’s DotID token), account scoping, and real-time data subscriptions automatically.

SDK Architecture

┌─────────────────────────────────────────────┐
│  Host Application (WES, ClearJanitor, etc.) │
│                                             │
│  ┌───────────────────────────────────────┐  │
│  │  @flexgalaxy/thingIO-widgets          │  │
│  │                                       │  │
│  │  ┌─────────┐ ┌──────────┐ ┌────────┐ │  │
│  │  │Dashboard│ │  Gauge   │ │Heatmap │ │  │
│  │  │ View    │ │          │ │        │ │  │
│  │  └────┬────┘ └────┬─────┘ └───┬────┘ │  │
│  │       │           │           │       │  │
│  │  ┌────▼───────────▼───────────▼────┐  │  │
│  │  │  ThingIO Data Provider          │  │  │
│  │  │  (React Context + WebSocket)    │  │  │
│  │  └────────────────┬────────────────┘  │  │
│  └───────────────────┼───────────────────┘  │
│                      │ REST + WS             │
└──────────────────────┼──────────────────────┘
                       ▼
                 ThingIO Backend

Application Integration

Applications register dashboards and widgets with ThingIO via APIs, then embed them using the React SDK:

Registration Flow

Application                         ThingIO
    │                                  │
    │  POST /dashboards               │
    │  {                               │
    │    "name": "Fleet Overview",     │
    │    "widgets": [...],             │
    │    "data_sources": [             │
    │      {"type": "telemetry",       │
    │       "device_types": ["amr"],   │
    │       "metrics": ["battery",     │
    │                    "position"]}   │
    │    ]                             │
    │  }                               │
    │──────────────────────────────────►│
    │                                  │  Creates dashboard
    │                                  │  Binds data sources
    │  200 OK                          │  to account's devices
    │  {"dashboard_id": "..."}         │
    │◄──────────────────────────────────│
    │                                  │
    │  Embed in app UI:                │
    │  <DashboardView                  │
    │    dashboardId="..." />          │

What Applications Can Register

Resource	Description	Example
Dashboard	A full-page view with multiple widgets	WES: “Warehouse Floor Status”
Widget	A reusable visual component	ClearJanitor: “Cleaning Coverage Heatmap”
Data pipeline	A processing pipeline for telemetry	WES: “Order throughput per hour”
Data source	A telemetry subscription configuration	ClearJanitor: “All cleaning robot positions”
Data sink	An output destination for processed data	WES: “Alert webhook for stuck robots”

Example: WES Dashboard Registration

{
  "name": "Warehouse Operations",
  "widgets": [
    {
      "type": "map",
      "name": "Live Floor View",
      "data_source": {
        "device_types": ["amr", "mhe"],
        "metrics": ["position", "status"]
      }
    },
    {
      "type": "gauge",
      "name": "Fleet Battery Status",
      "data_source": {
        "device_types": ["amr"],
        "metrics": ["battery"],
        "aggregation": "min"
      }
    },
    {
      "type": "line_chart",
      "name": "Orders Completed per Hour",
      "data_pipeline": "wes-order-throughput"
    }
  ]
}

Example: ClearJanitor Widget

{
  "type": "heatmap",
  "name": "Cleaning Coverage",
  "data_source": {
    "device_types": ["cleaning_robot"],
    "metrics": ["position"],
    "time_window": "current_shift"
  },
  "overlay": {
    "type": "zone_map",
    "source": "equator"
  }
}

Data Processing Pipelines

ThingIO wraps StreamPipes’ pipeline capabilities with account-scoped access control and FlexGalaxy API conventions.

Pipeline Types

Type	Description	Example
Transform	Enrich, normalize, or reshape telemetry	Convert GPS coordinates to zone IDs
Aggregate	Window-based computations	Average battery level per zone per 5 min
Detect	Pattern and anomaly detection	Battery drain rate accelerating
Correlate	Cross-device analysis	Congestion detection (too many robots in zone)
Infer	ML model inference on telemetry	Obstacle classification from sensor data

Pipeline Definition

Pipelines are created via API:

[Data Source]         [Processing]         [Data Sink]
 Account's     ──►   Filter / Transform   ──►  Dashboard widget
 enrolled             Aggregate                 Webhook
 devices              ML inference              Database
 (via Kafka)          Pattern detect            Notification

API Surface

Dashboards

Operation	Description
POST /dashboards	Create a dashboard
GET /dashboards?account=	List dashboards
GET /dashboards/{id}	Get dashboard with widgets
PATCH /dashboards/{id}	Update dashboard
DELETE /dashboards/{id}	Delete a dashboard

Widgets

Operation	Description
POST /widgets	Register a widget
GET /widgets?account=	List widgets
GET /widgets/{id}	Get widget definition
POST /widgets/{id}/publish	Publish widget to Marketplace

Data Pipelines

Operation	Description
POST /pipelines	Create a data pipeline
GET /pipelines?account=	List pipelines
GET /pipelines/{id}	Get pipeline definition and status
POST /pipelines/{id}/start	Start a pipeline
POST /pipelines/{id}/stop	Stop a pipeline

Data Sources and Sinks

Operation	Description
POST /sources	Register a data source
GET /sources?account=	List data sources
POST /sinks	Configure a data sink
GET /sinks?account=	List data sinks

Implementation

Aspect	Technology
Processing engine	Apache StreamPipes
Message bus	Kafka (dedicated MSK cluster, separate from ThingsBoard)
Dashboard storage	PostgreSQL
Time-series queries	ThingsBoard REST API / TimescaleDB
React SDK	React + TypeScript + IBM Carbon Design System
SDK packaging	npm (@flexgalaxy/thingIO-widgets)

Dependencies

Service	Relationship
DeviceAdmin	Resolves enrolled devices for data scoping
ThingsBoard	Telemetry data source (via Kafka)
StreamPipes	Underlying data processing engine
DotID	Authenticates API calls, account scoping
Equator	Spatial data for map overlays and zone context
Marketplace	Publishes reusable widgets as components

Consumed By

Consumer	Usage
WES	Fleet dashboards, order throughput, zone utilization (embedded via React SDK)
ClearJanitor	Cleaning coverage heatmaps, robot status dashboards (embedded via React SDK)
StarGate	Admin views for platform-wide telemetry monitoring
Applications	Register custom dashboards, widgets, and pipelines; embed via SDK
Operators	Visual monitoring of device telemetry and analytics