Welcome

Overview of the Heisenware platform, architecture, core concepts, and key terminology.

Heisenware is an industrial application platform. You build software visually and deploy it to production without writing boilerplate or setting up infrastructure. Underneath sits a full distributed architecture, so your apps scale from a single machine to a whole plant. When you need to go deeper, you keep direct access to the code and configuration.

The platform at a glance

Heisenware is divided into three core components that cover the entire application lifecycle:

APP MANAGER

Admin dashboard to create and manage apps, Members, and integrations.

APP BUILDER

Visual programming interface to build and test custom software applications.

PRODUCTION APPS

The live, end-user-facing applications created and run with Heisenware.

Hosting and architecture

The Heisenware architecture consists of the central platform and optional Agents. Each Account (tenant) runs in isolation and supports two deployment modes:

• Cloud deployment: The recommended way to use Heisenware. Your apps are hosted by us on Hetzner in Germany.

• On-premises deployment: You run the entire platform as a Docker application on your own local servers or private cloud.

Regardless of the deployment mode, you can use Agents to bridge separated networks. For example, if you host the platform in a corporate data center (IT) and need to access machines in a secured shopfloor network (OT), an Agent acts as the secure tunnel.

See it in action

See how to build and operate industrial applications in Heisenware.

Engineering philosophy and core concepts

Heisenware is a visual programming environment. To use it well, you need to understand a few engineering concepts that the platform keeps visible and under your control.

Transparency and flexibility

Heisenware keeps the underlying complexity visible and reachable. When you need custom logic, it is there.

• Visual with full code access: You build logic visually in the Backend Builder and keep direct access to developer tools like JavaScript expressions for data transformation and YAML for configuration.

• Extensible: When the built-in Functions are not enough, you wrap your own code (Node.js, Python, C++) into extensions that become native Functions.

Object-oriented scalability

Heisenware uses an object-oriented model. You build logic once and instantiate it across an entire fleet of devices.

• Classes (the blueprint): Reusable logic definitions, e.g. the OPC UA Client Connector or an Email Class.

• Instances (the asset): Living, stateful copies of a Class. You don't write code for machine A. You create an Instance of the OPC UA Client, name it opcua-machine-a, and configure it with the machine's IP and credentials.

• Stateful context: Member Functions know their context, e.g. which server to use, without passing global variables.

Native event-driven architecture

Industrial systems are asynchronous. Sensors spike, users click, and machines stop at unpredictable times. Heisenware applications are natively event-driven.

• Reactive logic: Backend Flows do not run in a linear loop. They sit dormant until a specific trigger (an Event) fires.

• Event sources: Triggers can be user interactions (UI events), data changes (e.g., a PLC tag update), or system lifecycle events.

• Non-blocking: This ensures your UI remains responsive while backend logic handles complex tasks asynchronously.

Distributed connectivity

We solve the "OT vs. IT" network gap by treating local hardware as a first-class citizen of the cloud platform.

• The bridge: Through Native Agents and Docker Agents, we securely bridge local, private networks (OT/Shopfloor) to the cloud without VPNs.

• Local execution: You can push backend logic (Connectors) to run locally on the edge device. The platform treats these remote Functions the same as cloud Functions.

Unified data binding

We eliminate the "glue code" typically needed to connect a frontend to a backend.

• Direct linking: In the App Builder, you connect a backend Function's Output directly to a frontend Widget's Property.

• Reactive UI: When backend data changes (e.g., a new sensor reading), the bound UI Widget automatically re-renders to reflect the new state.

Glossary

A quick-reference list of specific terms and concepts used across the Heisenware platform.

Term	Description
Account	The top-level organizational container representing a tenant (e.g., acme.heisenware.cloud). It houses all Workspaces, Members, and shared resources.
Agent	A secure, industrial-grade bridge running as a local service (Native, Docker, or LXC) within a private network. It securely tunnels data from local edge protocols (e.g., OPC UA, Modbus, S7) to the cloud Workspace.
App	A standalone, Progressive Web App (PWA) software application built, tested, and deployed entirely within Heisenware.
App Builder	The comprehensive visual development environment where Members design, build, test, and deploy applications.
App Manager	The central administrative dashboard for managing Accounts, Workspaces, apps, Members, and inbound integrations.
Backend Builder	The infinite canvas within the App Builder where developers create event-driven business logic by wiring together Functions into reactive Flows.
Code Adapter	Developer-written code (using Node.js, Python, C++, etc.) that wraps existing software libraries or algorithms so they can be integrated into Heisenware as Custom Extensions.
Custom Extension	A containerized module (typically built via a Code Adapter) loaded into the platform to expand native functionality with custom, proprietary backend tools.
Deployment	The process of publishing a specific version of an app, transitioning it from the App Builder environment to a live state accessible to Users.
Domain	The unique identifier combining your Account and Workspace (e.g., acme.default) used for internal routing and API integrations.
Event	A specific trigger, such as a user click, a data update, or a schedule interval, that initiates the execution of a Function Flow in the backend.
File Explorer	The panel in the App Builder used to upload, store, and manage static assets and files (e.g., images, CSVs, PDF templates) for use in your applications.
Filter	A Function extension that evaluates a boolean JavaScript expression to act as a logical gate, conditionally halting or allowing the continuation of a data Flow.
Flow	A reactive, event-driven sequence of connected Functions executing business logic in the Backend Builder.
Frontend Builder	The page-specific visual design canvas within the App Builder where developers compose responsive user interfaces using Widgets and static elements.
Function	An atomic, visual building block in the Backend Builder representing executable code that performs specific tasks (e.g., database queries, API calls, hardware control).
Function Explorer	The structural repository panel in the App Builder containing all available Functions, organized by categories like Connectors, Storage, Utilities, and Extensions.
Integration	A configured, authorized entry point allowing external systems, MQTT clients, or VRPC clients to securely send data to a Heisenware Workspace.
JavaScript Expression	Standard JavaScript logic evaluated on-the-fly within Modifiers or Filters to perform calculations, condition checks, or array manipulations.
JSONata	A lightweight query and transformation language natively supported in Heisenware for efficiently restructuring JSON data payloads.
Member	A developer, engineer, or administrator with access to the Heisenware platform to build and manage applications (strictly distinct from a User).
Modifier	A Function extension that transforms or reshapes data on-the-fly as it passes from one Function to the next within a Flow.
Page Explorer	The panel in the App Builder used to structure an application's hierarchy by creating, duplicating, and organizing pages and subpages.
Property	A configurable setting of a UI Widget that determines its behavior, data binding, or visual appearance.
PWA (Progressive Web App)	A modern web application standard that provides a native app-like experience (installable, responsive, offline-capable) directly from any web browser.
Tag (Versioning)	A named, point-in-time snapshot of an app's configuration (logic, UI, and bindings) that can be exported, restored, or used as a template blueprint.
User	An end-user who logs in or otherwise interacts with a live, published Heisenware app (strictly distinct from a Member).
VRPC (Variadic Remote Procedure Call)	The open-source, asynchronous communication protocol over MQTT that powers all distributed data exchange and remote function calls within the Heisenware ecosystem.
Widget	An interactive or display-oriented visual component (e.g., a chart, button, or form) placed in the Frontend Builder to construct the user interface.
Workspace	A dedicated sub-container within an Account used to securely isolate related apps, databases, files, and Members from one another.
YAML	A human-readable data serialization language used extensively in the Backend Builder for quickly configuring static Function Inputs and data structures.