Capabilities
One system, not three vendors
Connected products fail at the seams — between the firmware and the app, between the app and the backend. I work across all three, which means the seams are mine to get right.
Mobile
Native apps for products where the phone is the interface to a physical device.
Consumer apps are mostly a network call away from being correct. Apps that drive hardware are not — the connection drops mid-write, the device reboots, the user walks out of range holding a half-applied firmware update. Most of the work is in what happens when things go wrong.
I build for iOS and Android natively, share logic across both where it earns its keep, and treat the pairing and reconnection flow as the product rather than a detail.
- iOS & Android
- Native development, App Store and Play submission, staged rollout.
- Bluetooth Low Energy
- GATT design, pairing and bonding, reconnection, background modes.
- React Native wrappers
- Native libraries exposed to cross-platform teams without waiting on native work.
- Test infrastructure
- Appium suites and device farms, so a release is gated by real devices.
Embedded
Firmware for devices that ship, then have to keep working without you.
A fielded device is unforgiving. There is no rollback button, the update path has to survive a power cut halfway through, and the security has to fit in whatever flash is left after the application.
I work on Nordic silicon under Zephyr RTOS, where the power budget and the response-time budget pull against each other, and where cryptography has to fit in whatever flash is left after the application.
- Zephyr RTOS on Nordic
- BLE peripherals on a power budget, prototype through production firmware.
- Firmware update (DFU)
- Resumable, verified OTA paths with a safe rollback.
- Cryptographic protocols
- Signing and secure transport on constrained targets, including offline protocols.
- Protocol design
- Wire formats that survive version skew between app and device.
Cloud
The backend a fleet of devices reports into — and the bill that comes with it.
Device backends fail differently from web backends. Traffic is constant rather than bursty, clients are unreliable by design, and a bad deploy can mean thousands of devices reconnecting at once.
I define the whole estate in Terraform, keep latency a design constraint rather than something measured afterwards, and build the integration APIs that let other systems consume it.
- IoT ingest
- AWS IoT Core, MQTT brokers, device identity and authorisation.
- Serverless & IaC
- AWS Lambda with infrastructure defined in Terraform, built for low latency.
- Architecture
- Systems that start small without closing off the next step.
- Integration APIs
- REST services built to other people’s constraints — EMS providers, partner platforms.
How I work
Four things you can hold me to
I work end to end.
Firmware, app and cloud are one system. Splitting them across vendors moves the hard problems into the gaps between contracts, which is exactly where they hide.
I verify rather than assume.
Measure the built artefact, not the source. Run the workflow, do not reason about the YAML. Read the value back after a write. Most bugs pass a code review and fail a measurement.
I tell you what I did not do.
Every engagement has something left untested or deliberately scoped out. You will hear about it from me rather than find it later.
I hand over properly.
Documentation, accounts, credentials and a call. You own everything, and nothing depends on me staying reachable.