IoT App Development
Build IoT applications using any programming language and use it with the devices in your project.
What Is an App?
An IronFlock app is much more than a piece of software running on a device. It is a complete, self-contained product unit that brings together everything needed to operate a device in the field:
- An edge component — your application logic, running on the device inside a container. This is only one part of the app.
- A board — the dashboard users open in their browser to visualize data and interact with the device, defined as part of the app itself.
- A data schema — the table definitions that tell IronFlock what telemetry to collect and store in the time-series database.
- Parameters — configurable settings that operators can adjust per device or group without touching the code.
- Remote access configuration — tunnel definitions that expose device-side web UIs (like Node-RED or Grafana) directly in the browser.
- AI integrations — optional AI agent configurations that can answer questions about the device’s data.
When an app is added to a device or a group, IronFlock deploys the edge component, wires up the data collection, and makes the board and remote access available — everything at once, over the air.
When to Develop Your Own App
The IronFlock App Store offers ready-made apps for common use cases. But building your own app makes sense when:
- You have existing software — if your application can run in a container, it can become an IronFlock app. Wrap it with an IronFlock app definition and you immediately gain a dashboard, data collection, OTA updates, and fleet management. You can bring it as a code repository or as a finished Docker image: see How to Create an App.
- You need full control over business logic — custom sensor processing, edge AI inference, protocol conversion, or domain-specific algorithms.
- You want a tailored dashboard — the built-in board editor lets you design exactly the visualization and controls your operators need, without writing frontend code.
- You are building a product — package your software as an IronFlock app and distribute it to customers via the App Store, with optional paid licensing.
- You need to standardize across a fleet — one app definition, deployed identically to thousands of devices, with centralized parameter management.
What You Get
Developing an app on IronFlock gives you:
- Over-the-air deployment — push updates to all devices with a single click, no SSH required.
- Out-of-the-box data storage — define a table schema once; IronFlock creates the time-series database and starts collecting data automatically.
- A built-in dashboard — no separate frontend service needed; the board is part of the app and hosted by IronFlock.
- Configurable parameters — expose settings (API keys, thresholds, addresses) that operators can change per device or per group without touching the code.
- Remote access tunnels — surface web UIs running on the device directly in the browser through IronFlock’s tunnel infrastructure.
- App distribution — publish to the App Store and make your app available to other IronFlock users or customers.
How to Create an App
Every app has one Git repository. The root folder of this repository holds the Dockerfile or the docker-compose.yml that defines the edge component, and the .ironflock/ folder with the board, the data schema and the other templates. IronFlock builds every release of the app from this repository.
You create the app in the App Studio. Then there are three ways to fill it, depending on what you already have:
| You have | Repository of the app | Image of the edge component |
|---|---|---|
| Nothing yet | Created and managed by IronFlock | Built from the code in the repository |
| A code repository | Your own repository, linked to the app | Built from the code in the repository |
| A finished Docker image | Created by IronFlock, or your own | Your image, referenced from the repository |
Start in IronFlock
A new app gets a Git repository that IronFlock manages, on request with sample code that already runs. You write the code in the cloud IDE in your browser and run it on your devices from there. Nothing else needs to be set up.
See Writing Edge Code and Build Your First App.
Link Your Own Code Repository
If the code of your app lives in a repository on GitHub, GitLab or Bitbucket, link this repository in the app’s settings. It then is the repository of the app, and everything is done in it: the Dockerfile or the docker-compose.yml in the root folder, the .ironflock/ folder, and all of your code.
You keep your editor, your branches and your reviews. IronFlock builds the releases from what you push, and you can still open the app in the cloud IDE to run it on a device.
See Git Integration for the setup.
Import a Finished Docker Image
If your software already exists as a Docker image, its code does not need to come into IronFlock. The app still needs a repository, either the one IronFlock creates or one that you link. This repository then holds only the IronFlock integration of your image: a Dockerfile or a docker-compose.yml that references the image, and the .ironflock/ folder.
Reference the image in a Dockerfile:
FROM registry.example.com/acme/machine-gateway:2.4.1Or as a service in a docker-compose.yml:
services:
gateway:
image: registry.example.com/acme/machine-gateway:2.4.1
restart: unless-stoppedIf the image is in a private registry, link the registry to the app:
- Open the app’s Settings in the App Studio.
- Under Docker Registry Credentials, click Add Docker Registry.
- Enter the registry host exactly as it appears in the image reference, here
registry.example.com. For Docker Hub, enterdocker.io. - Enter the user and the password of the registry and save.
A public image needs no credentials.
When you create a release, IronFlock pulls your image with these credentials and stores it with the release. Devices that install the release get the image from IronFlock. They need neither access to your registry nor your credentials.
To add a dashboard, data collection or parameters to the image, add the files in the .ironflock/ folder as for any other app. See Docker & Compose for the details of both files.
App Architecture
An IronFlock app is a self-contained package with six components:
| Component | Configuration File | Description |
|---|---|---|
| Edge code | Dockerfile or docker-compose.yml | Application logic running on the device |
| Board | .ironflock/board-template.yml | User interface / dashboard |
| Data storage | .ironflock/data-template.yml | Database tables for telemetry |
| Parameters | .ironflock/env-template.yml | User-configurable settings |
| Remote access | .ironflock/port-template.yml | Tunneling ports for web UIs |
| AI agents | .ironflock/ai-template.yml | AI assistant integrations — see Defining Agents & Tools |
All configuration files in the .ironflock/ directory are optional. At minimum, an app needs a Dockerfile or a docker-compose.yml in the root folder of its repository.
In This Section
- App Structure — How an app is organized
- App Blueprint — How the parts of an app work together: state in tables, the board as the UI, device web UIs
- Writing Edge Code — The cloud IDE and code editing workflow
- IronFlock SDK — The library your edge code uses to write and read data, for Python, JavaScript, Go and C#
- Build with Claude Code — Let an AI coding agent write and check your app’s templates
- Docker & Compose — Containerizing your app
- Data Backend — Defining tables, collecting telemetry, latest-state tracking, and soft deletes
- Building Boards — Creating dashboards
- App Parameters — Exposing configurable settings
- Git Integration — Using GitHub, GitLab, or Bitbucket
- Releases — Publishing and deploying your app
- Pricing Your App — Setting up billing