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 distributed architecture, so your Apps scale from a single machine to a whole plant. When you need to go deeper, you reach the code and configuration directly.

The platform at a glance

Three core components 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 Apps 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. We host your Apps on Hetzner in Germany.

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

Whichever mode you choose, Agents bridge separated networks for you. For example, when you host the platform in a corporate data center (IT) and need to reach machines in a secured shopfloor network (OT), an Agent opens the secure tunnel.

See it in action

Watch how to build and operate industrial apps in Heisenware.

Engineering philosophy and core concepts

Heisenware is a visual programming environment. A few engineering concepts, all kept visible and under your control, make it click.

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 still reach developer tools directly, like JavaScript expressions for data transformation and YAML for configuration.

• Extensible: When the built-in functions fall short, you wrap your own code (Node.js, Python, C++) into Custom 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 connector.

• 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 give it the machine's IP and credentials.

• Stateful context: Member functions carry their own context, e.g. which server to use, so you pass no global variables.

Native event-driven architecture

Industrial systems are asynchronous. Sensors spike, users click, and machines stop at unpredictable times. Heisenware Apps handle this natively.

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

• Event sources: A trigger can be a user interaction (a UI event), a data change (e.g. a PLC tag update), or a system lifecycle event.

• Non-blocking: Your UI stays responsive while backend logic handles complex tasks asynchronously.

Distributed connectivity

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

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

• Local execution: You push backend logic (connectors) to run locally on the edge device, and the platform treats these remote functions exactly like cloud functions.

Unified data binding

Heisenware removes the "glue code" you would normally write to connect a frontend to a backend.

• Direct linking: In the App Builder, you connect a backend function's output straight to a frontend widget's property.

• Reactive UI: When backend data changes (e.g. a new sensor reading), the bound widget 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 local service (Native, Docker, or LXC) that executes backend logic at the edge, inside separated networks such as a secured shopfloor. It also tunnels data from local protocols (e.g. OPC UA, Modbus, S7) securely to the platform.
App	A standalone progressive web app (PWA), built, tested, and deployed entirely within Heisenware.
App Builder	The visual development environment where members design, build, test, and deploy Apps.
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 members create event-driven business logic by wiring functions into reactive flows.
Class	A reusable logic definition, or blueprint, that you instantiate to create working copies.
Code Adapter	Developer-written code (Node.js, Python, C++, etc.) that wraps existing software libraries or algorithms so they integrate into Heisenware as Custom Extensions.
Connector	A ready-made class for communicating with external systems and protocols, e.g. OPC UA, MQTT, databases, or email.
Custom Extension	A containerized module (typically built via a Code Adapter) loaded into the platform to expand native functionality with custom, proprietary backend tools.
Data Visualizer	A tool for exploring your data directly. You view, filter, and visualize entries without building an App. Currently in beta.
Deployment	Publishing a specific version of an App, moving 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 occurrence, such as a user click, a data update, or a schedule interval, that initiates the execution of a flow in the backend.
Extension node	A lightweight node (modifier, filter, recorder, or error handler) attached to a function to transform data, gate execution, record values, or handle errors within a flow.
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 Apps.
Filter	An extension node that evaluates a boolean JavaScript expression to act as a logical gate, conditionally halting or allowing a data flow.
Flow	A reactive, event-driven sequence of connected functions that executes business logic.
Frontend Builder	The page-specific visual design canvas within the App Builder where members compose responsive user interfaces from widgets and static elements.
Function	An atomic, visual building block in the Backend Builder representing executable code that performs a specific task (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.
Instance	A living, stateful copy of a class, configured for a specific asset. For example, an instance of the OPC UA client named opcua-machine-a holds one machine's IP and credentials.
Integration	A configured, authorized entry point that lets external systems, MQTT clients, or VRPC clients 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.
Listener	The input argument of a callback function that monitors external systems or instances for events and processes incoming payloads.
Member	A developer, engineer, or administrator with access to the Heisenware platform to build and manage Apps (strictly distinct from a user).
Modifier	An extension node 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 App's hierarchy by creating, duplicating, and organizing pages and subpages, and to configure menus per screen size.
PDF Template Editor	The tool in the App Builder for designing PDF templates that the fillTemplate function populates with dynamic data at runtime.
Property	Anything about a widget that can change, including its value, scale, visibility, and color. Any property can be bound to backend logic to drive the UI dynamically.
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.
Subflow	A reusable group of connected functions encapsulated as a single function for use in other flows.
Tag	A named, point-in-time snapshot of an App's configuration (logic, UI, and bindings) that you can export, restore, or use as a template blueprint.
Theme Editor	The tool in the App Builder for defining an App's colors, fonts, and visual styling, applied consistently across its pages and widgets.
Trigger	A function input or output configured to start flow execution when an event arrives, following the pattern on <source> <mode>, e.g. on input update.
User	An end-user who logs in or otherwise interacts with a live, published Heisenware App (strictly distinct from a member).
VRPC	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.