IoT engineering.
Your hardware works. The problem is the twenty metres between the device and the person holding the phone — pairing, sync, provisioning, updates, and the dashboard someone has to read at 2am. That's the layer we build.
What we build
We take the software side of connected products end to end, or slot into the part of it your team doesn't want to own.
Connected device apps
Native iOS companion apps for Bluetooth LE, Matter, and Thread hardware. Pairing and reconnection, live control, state synchronisation, and the failure paths most apps skip — device out of range, firmware mismatch, half-completed setup.
Firmware & app integration
Protocol and payload design across the hardware boundary, characteristic and service layout, versioning strategy, and OTA update delivery that tolerates a user walking out of range mid-transfer.
Apple ecosystem depth
HomeKit and Matter accessory integration, Apple Watch companions, home and lock screen widgets, Live Activities, and background execution designed around what iOS actually permits rather than what a spec assumed.
Offline-first architecture
Local-first data models, command queues, and explicit conflict resolution. Connectivity is treated as intermittent by default, so behaviour in a basement or a warehouse is designed rather than discovered.
Telemetry & dashboards
Device data ingestion, time-series storage, alerting, and operator interfaces built around the questions support and field teams ask — which units are failing, since when, and what changed.
Provisioning & security
Secure onboarding, credential and key handling on-device, certificate and identity flows, and setup journeys measured by completion rate rather than feature count.
How we work
Four phases. You can stop after any one of them, and everything produced along the way is yours.
Scope
A paid discovery week. We read the firmware, handle the hardware, and map constraints and unknowns into a written technical plan — useful even if you take it to someone else.
Prototype
The riskiest component first, almost always the connection layer. Feasibility gets settled early, on real hardware, while changing course is still cheap.
Build
Two-week cycles, each ending in a build you can install on a device. Direct access to the engineers throughout — no account manager in the middle.
Ship & hand over
App Store submission, technical documentation, and a codebase your team can take over. Ongoing support is available and optional.
Ways to work together
Discovery week
Fixed scope, fixed price. A technical plan, architecture recommendation, and honest risk assessment for a connected product you're considering or already struggling with.
Project build
Defined deliverable, milestone-based. Best when the hardware exists and the software scope can be written down — companion app, dashboard, or integration layer.
Embedded engineering
We join your team for a set number of days per month, in your tooling and your standups, for roadmaps that keep moving after launch.
Technical due diligence
An independent read on someone else's connected-product codebase before you acquire it, invest in it, or take it over.
Swift and SwiftUI on iOS, with embedded work in C and C++ and backend services in Python, Node, or Go depending on what your stack already runs. We fit the existing environment rather than arguing for a rewrite.
Tell us about the hardware.
What the device does, where the software is stuck, and when it needs to ship. We reply within two business days, and we'll tell you if we're the wrong fit.