The engine under everything.

Prism™ Core handles the orchestration, logic, and state of your entire IoT system—at scale, in real time.

Prism Core

What It Is

Prism Core is the orchestration engine at the heart of the ObjectSpectrum platform. Built on a scalable Node.js microservices framework, it manages the end-to-end lifecycle of IoT data — from ingestion to automation to visualization — while preserving complete contextual awareness of each device, user, and system rule.

Unlike off-the-shelf middleware or low-code IoT tools, Prism Core is purpose-built for high-throughput, low-latency IoT operations. It handles billions of events, tracks state across distributed device networks, and enforces deterministic logic without compromising speed or modularity.

Fewer bugs. Faster builds. Smarter scaling.

Core Architecture

At its core (pun intended), Prism is a distributed, event-driven runtime composed of stateless and stateful services:

  • Containerized deployment: Runs in Docker or Kubernetes, enabling horizontal scaling across environments
  • Multitenancy: Supports isolated runtime contexts, each with their own security boundaries and data models
  • Data and logic tier: Decouples raw data ingestion from system logic using a declarative rule engine and externalized state management

Prism Core tracks every device, user, rule, and output as an addressable object within its internal object model. State is durable, queryable, and version-controlled.

Data & Event Handling

Prism Core processes data as a sequence of events through a flexible rule engine:

  • Ingestion layer: Handles MQTT, CoAP, HTTP(S), TCP, UDP, and even custom protocol bridges
  • Schema validation: Ensures incoming payloads conform to user-defined schemas (JSON, CBOR, binary, etc.)
  • Rule engine: Written in a domain-specific language (DSL) that supports conditional logic, timers, alerts, and cross-object references
  • Object memory: Maintains a full in-memory + persistent state object for every device/node, including historical deltas

For time-sensitive applications, Prism supports sub-100ms event-to-action execution across distributed nodes.

Graphical representation of the Internet of Things

Scalability & Performance

Prism Core is designed for dynamic scaling across containerized clusters and hybrid architectures:

  • Horizontal scaling: Stateless services can autoscale based on system load
  • Cluster coordination: Internal task queues balance workloads for rule evaluation, notifications, and job execution
  • Event prioritization: Supports queue partitioning and has weighted throughput for critical workflows

In high-volume environments (e.g., telemetry from thousands of industrial assets), Prism has been tested to sustain throughput in the hundreds of thousands of events per minute with low processing latency.

Security

Security is implemented as a layered model across device, user, and system domains:

  • Device identity: Device provisioning includes key-based auth, certificate validation, or token-based authentication
  • Access control: Role-based and object-level permissions govern access to devices, rules, views, and data
  • Transport encryption: TLS is used for all inbound and outbound communications
  • At-rest security: Data encryption options vary by deployment but support standard encryption models for storage, logs, and backup

Audit logs track every configuration change, rule update, and user interaction in the system.

APIs & Integrations

Prism Core exposes a modern developer experience through:

  • REST and GraphQL APIs: Used for external app integration, system configuration, and data queries
  • Webhooks and callouts: Rules can trigger external HTTP calls with customizable payloads
  • Integration plugins: Support for third-party systems (ERP, SCADA, CRM) via connector modules or API bridges
  • Debug & trace tools: Real-time logs, synthetic event injectors, and sandbox environments for rule testing