Welcome to Heisenware

Heisenware is the industrial application platform for engineers who build real software. It combines the speed of visual development with the power of a full-stack environment. Unlike restrictive no-code tools, Heisenware exposes a sophisticated, distributed architecture designed for industrial scalability. It allows you to build, deploy, and manage production-grade applications without the overhead of boilerplate code and complex infrastructure setup.

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 & 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 Online GmbH 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.

Agents run as native binaries or Docker containers inside the target network to tunnel data from industrial protocols (S7, Modbus, OPC UA) or run custom code adapters locally on the edge.

See it in action

Watch how a production-ready application is built from scratch in 12 minutes.

Engineering philosophy & core concepts

Heisenware is not just a drag-and-drop interface. It is a visual programming environment. Mastering the platform requires understanding the engineering concepts we expose rather than hide.

Transparency & flexibility

Standard no-code platforms often act as "black boxes" by abstracting complexity so heavily that you hit a wall when you need custom logic. Heisenware operates transparently.

• Visual, yet code-capable: You build logic visually using the Flow builder, but you retain direct access to developer tools like JavaScript expressions for data transformation and YAML for configuration.

• No "no-code cliff": When pre-built blocks aren't enough, you don't hack workarounds. You extend the platform by wrapping your code (Node.js, Python, C++) into extensions that become native blocks.

Object-oriented scalability

Unlike linear scripting tools that struggle to manage multiple devices, Heisenware uses a strict object-oriented model. This allows you to build logic once and instantiate it across an entire fleet.

• Classes (the blueprint): Reusable logic definitions (e.g., an Email class or a generic Machine connector).

• Instances (the asset): Living, stateful copies of a class. You don't write code for "Machine A". You instantiate the Machine class with Machine A's specific 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 of terms

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

Term	Description
Account	Represents a tenant and is the highest level of organization. It is usually your company name and defines your URL (e.g., acme.heisenware.cloud).
Agent	An executable program deployed in a private network to establish a secure bridge to the cloud.
App	A stand-alone software application built with Heisenware. All apps are automatically PWAs.
App Builder	The visual programming environment where you design, build, and test applications.
App Manager	The administrative dashboard for managing workspaces, apps, members, and integrations.
Application logic	The backend of an app, consisting of integrations, databases, and logic flows.
Build time	The phase when a developer is actively designing and configuring an application in the App builder.
Code adapter	Custom code written to wrap existing software libraries, making them accessible as Heisenware blocks.
Command	An action that causes a temporary, non-persistent change to a widget's state, such as highlighting it.
Deployment	The process of publishing a version of an app, making it live for end-users.
Domain	Combines your account and workspace into an identifier (e.g., acme.default).
Event	A trigger the app responds to, such as a user click, database update, or timer.
Flow	A sequence of connected functions that defines how data is processed.
Integration	A configured entry point allowing external systems to send data to your account.
JavaScript expressions	A feature allowing the use of standard JavaScript expressions to perform simple data transformations or calculations on the fly.
JSON (JavaScript Object Notation)	A standard data format supported in Heisenware for structuring and exchanging data.
JSONata	A powerful query language used within Heisenware to reshape complex data on the fly.
Member	A user with access to build and manage applications (distinct from an end-user).
Property	A setting of a widget that can be read or changed by logic (e.g., the value in a circular gauge).
PWA (Progressive Web App)	Runs in a browser but offers a native-like experience (offline capable, installable).
Runtime	The phase when a deployed application is live and responding to user input.
Tag	A named, exportable version/snapshot of a Heisenware app.
Template	A specific tag serving as a blueprint for creating new apps.
User Interface (UI)	The visual part of an app that an end-user interacts with to view data, input data, and trigger actions.
Widget	A visual UI element used to display data (chart) or collect input (button).
Workspace	A container within your account used to organize related apps and members.
YAML	A human-readable data format used in Heisenware to configure functions.