Get in touch
IoT & Connected Devices

Firmware, the app and the cloud from one team

Most connected-product delays happen between the firmware team and the app team. We take both sides, so the protocol is agreed once and there is nobody to hand the bug to.

Discuss your device
What we build

Where we come in

Usually somewhere between a working prototype and a product people can actually set up on their own.

The app for your device

You have hardware and firmware; what is missing is the phone side. Also the usual rescue: an app that works on the founder's iPhone and on half of Android. We build the BLE or WiFi client, the pairing flow, the control screens and the store releases.

One team owns the protocol on both sides

From a bench prototype to a product

A breadboard ESP32 that works on your desk is not yet a device a customer can unbox. We take it through provisioning, error states, factory reset, updates and the things that only show up outside the lab.

Handles the paths that are not the happy one

Getting the device onto WiFi

The step where most support tickets are born. We implement provisioning over BLE or SoftAP, handle the 2.4GHz-only confusion, captive portals and wrong passwords, and tell the user what actually went wrong.

Setup the owner can finish without you

Telemetry and dashboards

Devices report over MQTT or HTTPS into a backend you own. Readings, state, errors and battery in one place, with alerts when a fleet member goes quiet.

You can see what the fleet is doing

OTA updates you can trust

Signed images, two partitions and rollback that actually fires: the new build only marks itself valid once it has proved it can still reach the cloud, which is the step most implementations skip and the reason rollback is so often cosmetic. Staged rollouts keep a bad release away from the whole fleet.

Ship firmware without a recall

Battery-powered devices

Deep sleep, wake sources and how often the device really needs to talk. Sleep current is rarely what drains the battery — the radio bursts and the external flash usually are. We measure on your board instead of quoting datasheet figures.

Runtime you can put on the box

Stack

What we work with

Espressif silicon and the transports around it, plus the app and backend that make a device usable.

Chips & firmware

  • ESP32
  • ESP32-S3
  • ESP32-C3
  • ESP8266 (legacy)
  • ESP-IDF
  • FreeRTOS
  • Arduino core

Connectivity

  • BLE / GATT
  • WiFi
  • MQTT
  • HTTPS / TLS
  • SoftAP & BLE provisioning
  • OTA

Apps & cloud

  • React Native
  • iOS & Android
  • Node.js
  • PostgreSQL
  • Time-series storage
  • Dashboards

ESP8266 is marked Not Recommended for New Designs by Espressif, so we use it for devices already in the field and start new work on ESP32-C3 or C6. Working with a different MCU or a vendor SDK? Tell us which; the app and cloud half does not change.

Scope

Where our part starts and ends

Being clear about this up front saves a month of discovering it later.

We do

  • Firmware on ESP32 / ESP8266 and comparable MCUs
  • BLE and WiFi protocol design, on device and in the app
  • Provisioning, OTA and device management
  • iOS and Android apps, including store releases
  • Backend, telemetry storage and dashboards
  • Debugging connectivity that works on the bench and fails in the field

We don't

  • Schematic capture and PCB layout
  • Enclosure and industrial design
  • EMC, FCC or CE certification
  • Mass production and supply chain

We work alongside your electronics engineer or contract manufacturer and speak their language.

Process

How a device project runs

01

Look at what exists

Your hardware, whatever firmware there is, and the protocol between device and phone. The first thing we write down is the protocol itself, versioned — so a firmware change and an app change can never disagree silently later. Then we say what we would keep and what we would redo.

02

Connect it end to end

The earliest useful milestone is a phone talking to your real board. We get that working first, because it is where the unknowns live. While boards are scarce or being respun, the app is built against a simulated device so it never waits on hardware.

03

Build the product around it

Provisioning, control screens, telemetry, OTA and the error paths. Firmware and app move together, so the protocol never drifts.

04

Field testing and release

Real phones, real routers, real walls. We test across Android makers, ship to the stores and stay on for the first firmware rollouts.

FAQ

Common questions

We don't have hardware yet. Can you still help?

Yes, if the electronics are coming from your engineer or a contract manufacturer. We can prototype on a dev board so the app and cloud are ready when the first boards arrive, but we do not design the board itself.

We already have firmware. Do you rewrite it?

Usually not. We read it, agree on the protocol, and extend it where the app needs something it does not expose. A rewrite gets proposed only when the existing code cannot carry OTA or security safely, and we say why.

Why does BLE work on iPhone but not on some Androids?

Because Android BLE differs by manufacturer and by OS version. The undocumented GATT error 133, a silent limit of five scans per 30 seconds, MTU that stays at the 23-byte default when nobody negotiates it, and OEM battery managers that kill background connections are all ordinary field failures. We test on a matrix of real phones from the makers your customers own, not on one flagship.

How long does it take?

A phone talking to your board is usually 2–3 weeks. A device someone can unbox and set up alone is 2–4 months depending on how much firmware exists and how many states the product has.

Who owns the firmware and the keys?

You do. Source, signing keys and cloud accounts are yours from day one and live in your accounts, not ours. If you later take it in-house, there is nothing to migrate.

Have a device to connect?

Tell us what the hardware is and where it is stuck. We'll say what we would do first and what it would take.

Discuss your device