Source code
Clean, documented, version-controlled, with full ownership rights. No lock-in to the original developer.
Firmware and Software
Firmware development that turns a working board into a product that ships
Custom embedded firmware for microcontrollers, FPGAs, and SBCs, whether bare-metal, RTOS, or embedded Linux. Production-ready code from an electronics engineer with 20+ years of experience.
Usually delivered as part of a full design project, by the same engineer from specification to production handoff. What is available on its own
20+ years experience
Clients in 15+ countries
Bench-tested in-house
You own every design file
54,000+
hours of client design work
27Published case studies
15+Countries served
Concept to prototypeEnd to end delivery
In-house labBench-verified, not just simulated
Why it matters
A board that works on the bench is not yet a product. Firmware is what makes it ship.
In-house teams know their product best, but firmware is one of the easiest places to under-resource, and the result is code that works on the bench, ships late, and turns into a maintenance liability. Bringing me in for the bring-up phase, a specific subsystem such as a BLE stack, OTA update, or motor control, or an entire product stack lets your team stay focused on what they do best while I handle the embedded specifics with someone who has done it before. Most of this is embedded firmware development on parts like the ESP32 and STM32, taken from first board bring-up through to tested, production firmware rather than a demo that only runs once.
What you get
The full embedded software stack, delivered to own
Bare-metal, RTOS, or embedded Linux, plus everything around the code that a product needs to ship and stay serviceable.
Architecture documentation
Module breakdown, interface contracts, RTOS task list with priorities, memory and stack budgets, and the design decisions that led there.
Build system
Reproducible toolchain configuration. Anyone with the source can build the exact same binary that was tested.
Drivers
Clean driver layer for every peripheral on the board, portable across hardware revisions.
Communication stacks
I2C, SPI, UART, USB, CAN, Ethernet, BLE, Wi-Fi, NB-IoT, LoRa, Modbus, MQTT. Whatever the product needs.
Bootloader and OTA update
Field-upgradeable firmware with rollback, signed images, and the ability to recover from a failed update.
Automated tests
Unit tests for critical logic, hardware-in-loop tests on the actual target, and a regression suite that runs on every build.
Production test firmware
A separate firmware image for end-of-line testing in manufacturing.
Companion app
Optional desktop or mobile application for configuration, monitoring, or data analysis.
Problems this avoids
The firmware failures that only surface in the field
The same mistakes show up in every shipped product that was not done by someone who has been through it before.
Memory leaks
Dynamic allocation that creeps over weeks until the device gets sluggish or crashes.
Race conditions
Concurrency bugs that pass QA, ship, and then surface intermittently in the field where they are impossible to reproduce.
Timing violations
Real-time deadlines missed under heavy load or edge conditions, causing dropped samples, missed packets, or corrupted state.
Stack overflow
Stack sized by guesswork, then overflowed the first time a deeper code path runs in the field.
Watchdog mishandling
Watchdog kicked from the wrong place so it never catches the actual hang it is there to detect.
Bricked devices on update
OTA with no rollback and no recovery, so a single bad release means a truck roll for every device.
How it works
From requirements to a release build
1
Architecture design
I define the software architecture from your requirements, choose RTOS or bare-metal, plan the module structure, and define the interfaces between components.
2
Hardware bring-up
I initialise core functionality: clock configuration, peripheral initialisation, and basic I/O, verifying the hardware works before building application logic.
3
Driver development
I implement drivers for every peripheral: ADC, DAC, timers, communication interfaces, and external devices, testing each one independently.
4
Application development
I build the application logic on top of the drivers and RTOS: state machines, control algorithms, and user interface handling.
5
Integration and testing
System integration testing verifies every component works together, and stress testing validates behaviour under edge conditions and resource constraints.
Who does the work
George Saliba
An electronics design engineer with 20+ years of professional experience across analog, digital, RF, and power designs, delivered to clients in 15+ countries. Your project is handled by the person who has shipped hardware like it, start to finish.
See the project portfolio
Questions
Frequently asked
What kinds of firmware development services do you offer?
Bare-metal firmware for microcontrollers (Cortex-M, AVR, MSP430, RISC-V), RTOS-based firmware (FreeRTOS, Zephyr, ThreadX), embedded Linux firmware on SBCs and SoMs, FPGA HDL, bootloader and over-the-air update systems, and companion desktop or mobile applications that interface with the device.
Do you do custom firmware development on existing hardware?
Yes. Existing hardware is a common starting point. The first step is reviewing the schematic and existing firmware (if any), then proposing an architecture that fits the hardware constraints. New firmware can be written from scratch or layered on top of an existing codebase.
Who owns the firmware source code at the end of the project?
You do. All source code, build scripts, documentation, and assets are delivered with full ownership rights on full payment, unless the engagement explicitly involves third-party libraries that require separate licensing. No ongoing dependency on the original developer for updates or releases.
What about firmware testing and validation?
Unit tests for critical logic, hardware-in-loop testing on the actual target, automated regression suite running on every build, and a separate production test firmware for end-of-line validation in manufacturing. All tests are delivered with the source so the team can extend them.
Can you handle the complete embedded software stack including bootloader and OTA?
Yes. A typical engagement covers bootloader, application firmware, drivers, communication stacks, OTA update with rollback, and any companion desktop tools. The bootloader and update mechanism are designed for field-deployable products that need to recover safely from interrupted updates.
What microcontroller families do you work with?
STM32 (Cortex-M0 through M7), nRF52 / nRF53, ESP32, NXP i.MX RT and i.MX application processors, Renesas RA, TI MSP430 and Tiva, Microchip PIC and AVR, Espressif ESP-IDF, RISC-V cores, and others. Embedded Linux on SBCs (Raspberry Pi CM, Toradex, NXP i.MX SoMs).
Do you offer firmware consulting and code review?
Yes. Firmware consulting and code review engagements are available for teams that have an in-house developer but want a senior pair of eyes on architecture, code quality, real-time correctness, or release readiness. Findings are delivered as a written report with prioritised recommendations.
How is the work priced?
Engagements are typically fixed-price for a defined scope (e.g. firmware bring-up for a specific board, bootloader implementation, BLE stack integration). Open-ended consulting and ongoing maintenance is hourly. A scope and quote is provided up front before any work starts.
Do you write embedded firmware for ESP32 and STM32?
Yes. Embedded firmware development on ESP32, STM32, and similar microcontrollers is core work, from first board bring-up and driver development through to tested, production firmware, including the low-level peripheral and communication code the product depends on.
Ready when you are
Get firmware that ships and keeps working in the field
From board bring-up to a full product firmware stack, I write the firmware alongside the hardware it runs on. Tell me what the product needs to do, and I will send back a quote with scope, timeline, and price.
Request a Firmware Quote