Zelo Integrator

Industrial Data Integration Platform Connecting Equipment, Data, and Decisions

Version 1.0 | Zelo Industrial Solutions d.o.o.

Executive Summary

Manufacturing operations today depend on dozens of heterogeneous systems — PLCs, SCADA servers, relational databases, quality measurement devices, and enterprise applications — each speaking a different protocol and storing data in isolated silos. Bridging these systems has traditionally required expensive middleware platforms, lengthy integration projects, and specialized vendor lock-in.

Zelo Integrator is a lightweight, high-performance industrial data integration platform that eliminates these barriers. It provides a unified visual environment to connect, transform, route, record, and act on industrial data — without writing integration code. Where custom logic is needed, the platform supports extensible process modules in Python, Node.js, or .NET.

Following paragraphs outline the technical architecture, capabilities, and deployment options of Zelo Integrator for engineering teams and technical decision-makers evaluating data integration solutions for manufacturing environments.

The Problem

Modern manufacturing facilities face a common set of integration challenges:

  1. Protocol fragmentation — Equipment communicates via OPC UA, Modbus, proprietary SQL databases, and file-based interfaces. Each data source requires different connectivity logic.

  2. Data silos — Measurement data, event logs, quality records, and process parameters live in disconnected systems. Correlating data across sources requires manual effort.

  3. Rigid middleware — Traditional integration platforms (Kepware, AVEVA, OSIsoft PI) are powerful but expensive, complex to configure, and difficult to modify once deployed.

  4. Slow time-to-value — Integration projects typically take months. Configuration changes require vendor support or specialized engineering.

  5. No built-in intelligence — Most middleware simply moves data. Adding conditional logic, threshold detection, or alerting requires additional systems.

The Solution

Zelo Integrator addresses these challenges through a microservice-based architecture where each integration concern is handled by a specialized, independently configurable service — all orchestrated through a visual process editor and a high-performance messaging backbone.

Core Design Principles

Principle Implementation
Zero-code configuration Visual drag-and-drop process editor for defining data flows
Runtime reconfiguration All services accept configuration changes without restart
Protocol abstraction Connectors normalize all data into a unified message format
Horizontal composition Services are composed into pipelines via publish/subscribe messaging
Cross-platform All core services run natively on Windows and Linux
Multi-tenant capable Cloud deployment supports isolated per-customer instances

Architecture

System Components

Zelo Integrator consists of three layers:

1. Core Services Layer (Go) Twelve independently deployable microservices written in Go, each compiled to a single native binary with no external runtime dependencies:

  • Manager — Central orchestrator that starts, stops, monitors, and configures all other services
  • OPC UA Connector — Bidirectional bridge to OPC UA servers (read subscriptions + write-back)
  • OPC UA Collector — Read-only OPC UA data collection for monitoring without write access
  • SQL Connector — Bidirectional bridge to relational databases (polling + insertion)
  • Comparator — Conditional logic engine for threshold detection and data-driven triggers
  • Simulator — Synthetic data generator for testing and validation
  • Inspector — Real-time message flow debugger for diagnostics
  • Event Logger — Persistent event storage with configurable retention
  • Time Recorder — Time-series data recording to MongoDB time-series collections
  • Length Recorder — Position-based measurement recording per processing run
  • Flatness Recorder — Zone-based flatness measurement recording per material batch
  • Mailer — SMTP email notifications triggered by data events

2. API Layer (Node.js/Express) RESTful API server providing:

  • Process configuration management (CRUD, version control, activation)
  • OPC UA server browsing (node discovery)
  • SQL database introspection (table/view discovery)
  • Recorded data retrieval (time-series, events, process data)
  • Role-based access control (Administrator, Operator, Manager, Technologist)

3. Presentation Layer (Angular) Single-page web application featuring:

  • Visual process flow diagram editor (Syncfusion Diagrams)
  • Interactive time-series charts (Plotly.js)
  • Process data and measurement viewers
  • Event log explorer
  • Real-time process status monitoring
  • Multi-language support (ngx-translate)

Messaging Architecture

All inter-service communication flows through NATS, a high-performance messaging system:

  • Data messages use publish/subscribe patterns — services subscribe to named subjects and publish transformed data to downstream subjects
  • Control messages use request/reply patterns — the Manager and UI send commands (START, STOP, CONFIGURE, STATUS) and receive synchronous responses
  • Message format is a canonical JSON structure carrying typed value maps (floats, integers, strings, datetimes) with source and internal timestamps
┌──────────┐    ┌──────────┐    ┌──────────┐    ┌──────────┐
│ OPC UA   │───▶│Comparator│───▶│  Event   │───▶│  Mailer  │
│Connector │    │(threshold│    │ Logger   │    │(alert    │
│(data     │    │ check)   │    │(persist) │    │ email)   │
│ source)  │    └──────────┘    └──────────┘    └──────────┘
└──────────┘         │
                     ▼
               ┌──────────┐
               │  Time    │
               │Recorder  │
               │(history) │
               └──────────┘

Each arrow represents a NATS subject. Adding, removing, or rerouting connections requires only a configuration change — no code modifications, no restarts.

Connectivity

OPC UA

The OPC UA Connector and Collector support:

  • Endpoint discovery with configurable security policies
  • Subscription-based monitoring with configurable polling intervals (≥10ms)
  • Trigger-based messaging — outbound messages fire only when a designated trigger node changes value
  • Write-back — incoming messages can write values to OPC UA nodes with data type mapping across all standard UA types (Boolean, Int16/32/64, UInt8/16/32/64, Float, Double, DateTime, String)
  • Auto-reconnect — recovers from connection failures with exponential retry
  • Node browsing — the UI can browse the OPC UA server's address space for configuration

SQL Databases

The SQL Connector supports five database engines through a single service:

Database Driver Tested Versions
Microsoft SQL Server go-mssqldb 2016+
PostgreSQL pgx 12+
MySQL / MariaDB go-sql-driver 5.7+ / 10.3+
SQLite modernc.org/sqlite 3.x
Oracle godror 19c+

Features:

  • Primary-key–based polling — reads only new rows since last poll, avoiding duplicates
  • Configurable poll intervals per message type
  • Batch insertion — incoming messages are buffered and inserted in batches
  • Connection resilience — automatic reconnection on database connection loss

Data Recording

Zelo Integrator includes three specialized recording services, all using MongoDB as the storage backend:

Time-Series Recording

  • Native MongoDB time-series collections for optimal compression and query performance
  • One collection per signal, automatically created on first data point
  • Configurable retention (seconds, minutes, hours, days)
  • Per-signal metadata stored in a Settings collection (display name, unit, scale factor)

Process Data Recording (Length & Flatness)

  • One MongoDB collection per processing run (material batch)
  • Index collection for cross-referencing processing IDs, material names, and iteration numbers
  • Position-based recording with full measurement data at each sample point
  • Zone-based flatness arrays for strip/sheet flatness profiling

Event Logging

  • Buffered writes (5-second flush interval) for high-throughput scenarios
  • TTL-based retention using MongoDB TTL indexes
  • Automatic index management (create, update, drop) on retention changes

Conditional Logic & Alerting

The Comparator service enables data-driven decision making without custom code:

  • Compare any two values: message field vs. message field, or message field vs. constant
  • Supported operators: EQ, LT, LE, GT, GE
  • Supported types: integers, floats, strings, booleans, datetimes
  • Trigger modes: fire on each true evaluation, or only on state change (rising edge)
  • Output messages can include transformed values with configurable coefficients

Combined with the Mailer service, this creates a complete alerting pipeline: detect condition → generate event → send notification — all configured visually.

Extensibility

For scenarios requiring custom business logic, Zelo Integrator supports custom process modules in:

  • Python — ideal for data science, analytics, and ML model integration
  • Node.js — suitable for API integrations and rapid prototyping
  • .NET (C#) — for enterprise integration and complex business rules

Custom processes use the same NATS messaging infrastructure as built-in services. Code templates are provided for each language, and the UI includes a code generation tool that scaffolds a ready-to-run custom process from the current configuration.

Deployment Options

On-Premise (Single-Tenant)

Standard deployment for plant-floor installations:

  • Requirements: Windows Server or Linux, MongoDB, NATS server
  • Footprint: All Go services are single static binaries, ~8MB each
  • Management: Single Manager process orchestrates all services
  • All communication stays within the local network

Cloud (Multi-Tenant)

SaaS deployment for remote monitoring and multi-site management:

  • Isolation: Each customer gets a dedicated NATS instance, MongoDB database, and process set
  • Routing: Caddy reverse proxy with per-tenant URL routing
  • Orchestration: Automated initialization script bootstraps all services per user
  • Security: HTTPS termination at Caddy, role-based API access control

Security

Layer Mechanism
API access Role-based authorization (4 roles) on all endpoints
Transport HTTPS via Caddy reverse proxy; OPC UA security policies (certificates)
Browser HSTS, CORP, COOP, X-Content-Type-Options headers
Licensing Hardware-bound license verification (BIOS/DMI fingerprinting)
Data MongoDB authentication; SQL database credential management

Performance Characteristics

Metric Capability
OPC UA polling ≥10ms interval, 1600-message channel buffer
NATS throughput 2048-message data channel buffer per service
DB write batching 5-second flush intervals for recording services
Message latency Sub-millisecond NATS routing + JSON encode/decode
Startup time Services operational within 1-2 seconds of launch
Memory footprint Each Go service: 10-30MB typical

Competitive Positioning

Feature Zelo Integrator Kepware Ignition Node-RED
OPC UA bidirectional ✅ ✅ ✅ Via plugin
Multi-DB SQL ✅ Limited ✅ Via plugin
Visual process editor ✅ ❌ ✅ ✅
Time-series recording ✅ (native) ❌ ✅ Via plugin
Conditional logic ✅ (built-in) ❌ Scripting ✅
Custom code (multi-lang) Python/C#/JavaScript ❌ Python/Jython JavaScript
Single-binary services ✅ ❌ ❌ ❌
Cloud multi-tenant ✅ ❌ ❌ ❌

Summary

Zelo Integrator delivers a modern, lightweight, and highly configurable industrial data integration platform. Its microservice architecture, visual configuration approach, and multi-protocol connectivity make it suitable for:

  • System integrators building turnkey automation solutions
  • Manufacturing engineers connecting shop-floor equipment to data systems
  • OEMs embedding data connectivity into their machine offerings
  • Operations teams needing real-time monitoring, alerting, and data recording

For technical demonstrations, proof-of-concept deployments, or partnership inquiries, contact Zelo Industrial Solutions d.o.o.