Fleeto Private Local IoT Control Without Cloud Infrastructure

I built Fleeto because I wanted a simple answer to a problem that kept bothering me: why should a small IoT setup need cloud infrastructure just to register devices, collect telemetry, show dashboards, and send commands?

The initial idea came from a very practical place. I was thinking about setting up a home security system for my apartment, but most existing solutions depended on cloud services. I did not like that. For this kind of system, I wanted the important parts to stay local: device data, command execution, telemetry history, and the management UI.

So I built Fleeto as a private IoT control server that can run on a Raspberry Pi inside the local network. Devices connect to it over MQTT with mTLS, Fleeto stores their messages locally, and the user gets dashboards and commands without running a cloud broker, cloud database, or hosted backend.

Who Fleeto Is For

Fleeto is mostly interesting for IoT builders who already know the pain of stitching together a broker, device authentication, storage, dashboards, and command execution.

If you build ESP32, ESP8266, Raspberry Pi, or other small device projects, Fleeto gives you a local control point for experiments and small deployments. It is not trying to be an enterprise IoT fleet management platform. The current version is closer to a private control room for small IoT systems where one technical person wants to understand and operate the whole setup.

Fleeto Demo

Before jumping to the technical details, let's see a product demo to understand what we are discussing. The testing devices were:

• Raspberry Pi 2 Zero W, which was running the Fleeto server.
• ESP32, which was running a WiFi scanner that was detecting devices in the local network as the testing IoT device.

Loading...

Fleeto telemetry dashboards

And there is a home page for Fleeto with metrics from ESP32:

Loading...

The system looks like a highly customizable and lightweight Grafana dashboard that displays data from IoT devices. It supports:

• Line graph visualization widget
• Table visualization widget
• Command execution widget

Otherwise, it looks very similar to Grafana because I took inspiration from Grafana while building this project. There is a list of dashboards where the user can configure different dashboards:

Loading...

The user can choose one dashboard as the home dashboard and it will be shown on the home page (see the "Home dashboard" label on the screenshot above).

The configuration of the dashboard looks like a JSON file with a specification for how to render each widget (line or graph):

Loading...

By the way, with a JSON structure it's very easy to create a dashboard with OpenAI Codex by just explaining what I want and pointing to the code. Codex actually created this dashboard from the example.

Fleeto Device Configuration

During the configuration of devices, the user should specify telemetry and command JSON schemas to validate messages received by the server. If a device sends a message that doesn't follow the configured schema, then Fleeto will not handle it:

Loading...

This is required to minimize bugs and make Fleeto flexible enough to support any number of devices. Also, the specified JSON schema will help developers of IoT devices integrate with Fleeto, see what error occurs during message processing, and not guess why it does not work.

Also, during the first device creation, mTLS certificates will be generated and developers of IoT devices will need to copy them and use them in their code (don't worry about the raw screenshot, it's just a test system):

Loading...

Fleeto Auditability

All messages received by Fleeto are stored as-is in the database for audit purposes:

Loading...

Also, the user can open any raw message and see what was sent: Loading...

This is very useful during development, debugging, and incident investigation.

Main Features

Loading...

From the demo above, I can say that Fleeto's main features are:

• Secure connection between IoT devices and the Fleeto server with mTLS and MQTT
• Private deployment on Raspberry Pi while minimizing cloud risks like hacker attacks on the common server.
• Full customizability for client needs due to Grafana-like dashboards.

After understanding what Fleeto does, let's discuss the technical side of the project.

Tech Stack

Because deployment should be local on the Raspberry Pi, I decided to use:

• Go - to have a lightweight deployment.
• SQLite - one SQLite file was used for settings like devices, users, and dashboards. And another SQLite file was used for high-load data like messages and telemetry. This was done to decouple this data due to strict write requirements for telemetry data.
• MQTT - to allow multiple devices to connect to Fleeto in an easy way.
• Embedded MQTT broker mochi-mqtt
• mTLS - to ensure secure communication between devices and server
• HTTPS - to have secure communication between the user and the Fleeto management console
• HTMX - because deployment should work on the Raspberry Pi, using such a heavy JS framework like React wasn't an option, that's why I decided to build a minimalistic UI.

This tech stack gives me everything I need: lightweight and secure deployment in the local network on Raspberry Pi.

Of course, it is not the best choice for cloud deployment, but for the V1 I decided to go only with Raspberry Pi, and if I prove that the project makes sense, I will add cloud support for Fleeto as well. But for cloud deployment, Fleeto infrastructure will be changed to:

• SQLite -> Postgres - I need a normal database to handle high load and scale Fleeto.
• mochi-mqtt -> NATS - MQTT broker should be dedicated to scale Fleeto.

Everything else will be the same. But again, these are plans for the future, for now Fleeto is running on Raspberry Pi.

System Design

Loading...

All devices connect via MQTT with mTLS to the Fleeto server, which runs on the Raspberry Pi. The user also connects to this server via web browser to manage devices and see metrics.

Project Architecture

Because Fleeto should run on the Raspberry Pi and in the cloud, I was thinking about building a flexible project architecture to quickly replace MQTT and database layers with heavier cloud ones like Postgres and NATS. That's why I used Clean Architecture:

Loading...

The Fleeto app is split into 3 layers:

• infra - an infrastructure layer which contains code to handle the database layer, MQTT layer, and web. Everything that goes in and out of the app.
• app - an application layer which contains code to run business logic and connect multiple domain models together.
• domain - a domain layer which contains domain models and core business logic.

This architecture allows me to replace infra components without code refactoring in other layers because the infra layer depends on app and domain but none of them depends on infra. A more detailed explanation of this architecture is in this article: DDD, Hexagonal, Onion, Clean, CQRS, ... How I put it all together. For now I will focus solely on my problem with replacing SQLite and Mochi with Postgres and NATS without code refactoring.

Loading...

As you can see, Clean Architecture allows me to do it without any business logic code changes, only infrastructure code. That's why Fleeto is so flexible and supports Raspberry Pi and in the future will support cloud deployment as well.

Roadmap

For now, Fleeto is at the v1 development stage. I have a working prototype but need to finish fixing some bugs and think about distribution. I'm thinking about an open-source model but will answer this question later.

Loading...

1. Finish v1 development and build another PoC product to improve Fleeto
2. Add RBAC support to allow multiple users with different access levels for one facility
3. Add backups support in S3 to not lose data
4. Add cloud support by making infrastructure pluggable and test Fleeto in the cloud

Conclusions

Fleeto is a private IoT device management platform that is able to run on Raspberry Pi or can be deployed in the cloud. It was developed using my experience of building high-load critical systems across different domains, especially in the IoT domain. I used technologies to minimize resource usage and maximize server availability. I have some plans for this project, but if you like it, feel free to reach out to me to discuss potential collaboration options.

If you like Fleeto and want to try it in your environment, then feel free to contact me. I will help you to set up and use it. Or if you have some ideas of features which you need, I will be happy to speak with you.