Firmware, drivers and device stacks that ship
Embedded Software Development
We build the software that runs on the device itself — board support packages, drivers, protocol stacks, management agents and the user-space applications above them — for teams shipping routers, ONTs, access points, gateways and industrial equipment.
CPE and IoT device manufacturers, ODMs, silicon vendors and operators specifying their own hardware.
- 25+
- years building device software
- Linux
- RTOS and bare-metal targets
- BSP
- to application, one team
Device software is unforgiving in a way application software is not.
There is no rolling back a bad release on two hundred thousand units in subscriber homes. Memory is measured in megabytes, boot time matters, the watchdog is real, and the bug you shipped is in somebody's living room until the next firmware window.
Twenty-five years of shipping code onto devices that cannot be patched easily once they leave the factory.
What it costs you today
- Resource constraints that rule out the obvious implementation
- Real-time behaviour that unit tests do not catch
- Field failures that cannot be reproduced on a desk
- Silicon vendor SDKs that are late, partial, or both
How we work
The principles that shape the engagement, and why they are worth holding to.
We work at every layer, not just the easy one
Bring-up on new silicon, kernel and driver work, the networking stack above it, the management agent, and the local interface a technician actually uses. One team owning all of it removes the integration gap where most device projects lose their schedule.
Standards on the device, not just the server
We build the ACS side of TR-069 and TR-369 as a product, so we know precisely how a device should behave on the wire — session handling, data model coverage, event reporting, bulk data collection. That knowledge goes straight into the agent we write for your hardware.
Upgrade paths that survive the field
Dual-bank images, signed firmware, anti-rollback and a fallback that actually boots when the new image does not. The upgrade mechanism is the one piece of device software that has to work first time, every time, because it is what fixes everything else.
Tested on hardware, continuously
Builds flash to real boards in a rack and run regression against them, not just against an emulator. Timing bugs, memory pressure and driver regressions surface in CI rather than in a customer trial.
What we deliver
- Board support packages and kernel porting for new silicon
- Device drivers: Ethernet, Wi-Fi, PON, USB, serial and GPIO
- OpenWrt-based and vendor-SDK-based firmware builds
- TR-069 and TR-369 management agents on the device side
- Data model implementation and parameter mapping
- Networking stacks: bridging, routing, QoS, firewall and NAT
- Secure boot, signed images and anti-rollback
- Field-safe upgrade with dual-bank and fallback
- User-space applications, CLI, web GUI and local APIs
- Automated build, flash and regression on real hardware
Capabilities in full
The detail behind each area, so you can see whether we cover what you need.
Platform and bring-up
- New silicon bring-up and board support packages
- Linux kernel porting, patching and configuration
- RTOS and bare-metal targets where Linux does not fit
- Bootloader integration and secure boot chains
- Device tree, pin muxing and peripheral enablement
- Flash layout, partitioning and overlay filesystems
- Memory and footprint optimisation
- Power management and thermal behaviour
Networking and protocols
- Bridging, VLANs, routing and NAT
- Wi-Fi driver integration and hostapd configuration
- PON and Ethernet WAN handling
- QoS, traffic shaping and firewall
- IPv6 and dual-stack support
- TR-069 and TR-369 agents with data model coverage
- DHCP, DNS and service discovery
- Diagnostics: speed test, ping, traceroute, spectrum
Quality and delivery
- Automated build pipelines per board and per variant
- Hardware-in-the-loop regression racks
- Protocol conformance testing against the standard
- Interoperability testing against real management systems
- Static analysis, sanitisers and memory-leak hunting
- Field crash capture and post-mortem analysis
- Release engineering and signed artefacts
- Long-term maintenance and security backports
How we engage
Three common shapes. We will scope to whichever fits, or to something else entirely.
Full firmware ownership
We take the device software end to end, from silicon bring-up to the release you ship, and maintain it across the product life.
Agent and stack integration
You have firmware; we add the management agent, the data model and the diagnostics that make it manageable at fleet scale.
Rescue and hardening
An existing build that is unstable, leaking memory or failing conformance. We find out why and make it shippable.
Other services
Most engagements draw on more than one of these.
WiFi and IoT
Wireless design, IoT integration and custom applications
ExploreDevOps
Build, test and release pipelines for network software
ExploreIndustrial IoT
Connectivity and telemetry for plant, field and infrastructure
ExploreTraining and Consulting
Standards expertise, architecture review and team enablement
ExploreCommon questions
Do you work on our hardware or your own?
Yours. We do not sell hardware, so there is no pressure to move you onto a particular board. We have worked across the main networking silicon families and the SDKs that come with them.
Can you take over firmware someone else wrote?
Often that is the request. We start with an assessment — build reproducibility, dependency state, known field failures — and give you a written view of what is worth keeping before anyone commits to a rewrite.
How does this connect to your platforms?
Directly. Because we build JustiFi ACS, we know how a device should behave against a management system, and we test the agents we write against a real one rather than against a specification alone.
Talk to us about Embedded Software Development
A scoping conversation with an engineer, not a sales call. If we are not the right fit, we will tell you.