IoT Firmware Development: Best Practices for Scalable Solutions

Working on your Internet of Things project? If you’ve ever found IoT firmware development to be a real head-scratcher — dealing with energy efficiency, security, scalability, and other IoT firmware vulnerabilities — our post might help you out.

Having built secure controllers for our access control system Propuskator and scalable firmware for MyBox charging stations, WebbyLab knows what it takes to deliver robust, easy-to-maintain, and upgradeable firmware.

The firmware for MyBox devices is a whole framework that allows you to work with both custom hardware and ready-made third-party devices, unite them within a single ecosystem, and configure interactions.

Yehor Fedorov

IoT Project Team Lead at WebbyLab

MyBox charging station

In this article, we’ll break down every important aspect of IoT firmware development — the steps to take, the challenges to prepare for, and the IoT firmware best practices to follow — all based on our extensive Internet of Things background in delivering custom IoT software solutions.

Highlights:

• IoT firmware needs more than just code. Energy efficiency, security, and scalability are a must.
• OTA updates are non-negotiable. No more physical access for firmware upgrades — just remote improvements.
• Are hardware limitations holding you back? Arduino IDE is a solution.

Propuskator controller MVP

What Is IoT Firmware?

IoT device firmware is software installed directly onto a device’s hardware. It allows the device to function, communicate, and interact with an entire IoT ecosystem. Simply put, it’s a layer between the physical hardware and the software systems that control and monitor IoT devices.

The main functions of firmware in IoT include:

• Device control: Manages device operations, collects data from sensors, and transmits data to other devices.
• Communication: Supports protocols like Wi-Fi, Bluetooth, MQTT, and more for communication with IoT networks and other devices.
• Operation logic: Enables automation, processes events, and reacts to triggers within the ecosystem.
• OTA updates: Provides over-the-air (OTA) firmware updates for stable improvement and maintenance.

With these features in place, the embedded firmware architecture diagram would look like this:

An example of IoT firmware architecture.

Now that we’ve covered the basics of IoT firmware development how it works, let’s move on to the practical steps involved in creating it.

What Are the Key Steps in IoT Firmware Development?

IoT firmware development starts with a well-thought-out plan. Here are the steps to make the entire process smoother:

Gathering Requirements

Before coding immediately, make sure you understand your project requirements clearly. In particular, identify the essential features your IoT device needs to succeed.

Even in the early stages of communication with our customers, we convey the necessity of many functions — even if they are invisible to users or not obvious at first glance. Based on our experience, we understand the challenges that every IoT device manufacturer faces in the first years of production and try to build the necessary functions into the firmware from the outset.

Kostiantyn Oliynyk

Head of IoT at Webbylab

Selecting Hardware and Tools

Next, you want to choose the right hardware and tools — because this determines your firmware compatibility and efficiency. For example, developers often compare Raspberry Pi and Arduino to choose the best option for their projects. The hardware you can pick includes microcontrollers like ESP32, STM32, AVR, and ARM Cortex.

Plus, here’s a table with the main programming languages and their use cases in IoT firmware implementation:

Writing and Testing Firmware

You can build your IoT firmware using any of the languages we listed above. But that’s just the beginning. At this point, you also need to test the firmware thoroughly. You can do this with tools like UART and JTAG.

For more insights on the matter, you may explore our IoT testing guide.

Deployment and Updates

Once your firmware is tested and bugs are fixed, you can deploy it for real-world use. The best IoT firmware development businesses also introduce regular OTA updates. Why? Because this is a way to ensure the firmware remains secure and up-to-date.

How Does Firmware Development Differ from Software?

At first glance, firmware and software might seem similar. But several key features set them apart:

1. Limited resources

Memory capabilities: IoT devices often have RAM and flash memory limitations.

Limited computing power: Microcontrollers typically operate with low performance compared to general-purpose processors.

Energy efficiency: Firmware code must be optimized for minimal power consumption, especially for battery-powered devices.

2. Working with hardware

Drivers: Firmware interacts directly with sensors, actuators, and other peripherals.

Real-time functionality: Requires precise synchronization and control over hardware events.

3. No operating system (or simplified OS)

Bare-metal programming: Involves controlling hardware resources directly without an OS.

RTOS: Real-time operating systems provide lightweight multitasking capabilities.

Maksym Lesnikov

Chief Technology Officer

Helped dozens of startups create effective digital products.

Get a Consultation

ESP microcontrollers for an A/C drain line cleaner.

4. Cyber security

Data protection: Uses encryption (e.g., TLS) for secure data transmission.

Device authentication: Ensures only authorized devices can connect.

Regular updates: OTA updates allow for routine vulnerability fixes.

5. Stability and reliability

Fault tolerance: Devices must remain functional even when errors happen.

Recovery mechanisms: Include options like rebooting or using firmware backups.

6. Logging and debugging

Hardware limitations: Debugging tools are often constrained by the device’s capabilities.

Testing tools: UART, JTAG, and SWD are commonly used for IoT devices firmware analysis.

7. Dependence on the environment

Harsh conditions: Devices must operate under varying temperatures, humidity, and dust levels.

Network stability: Firmware must handle radio interference and unstable networks effectively.

8. Testing

Real-world testing: Physical devices must be tested thoroughly in real conditions.

Emulation: Limited by microcontroller capabilities.

The Challenges of IoT Firmware Development

Let’s now recap the challenges you should address when building IoT device firmware components:

When working on the features of advanced IoT firmware, optimizing battery-powered A/C drain line cleaners was our number-one hurdle and, undoubtedly, room for growth.

One of our biggest challenges was creating an IoT device and implementing all the business logic using only batteries as a power source. To succeed, we had to delve deeply into the operation of ultra-low-power (ULP) processors on ESP microcontrollers and understand the IDF framework. Nevertheless, we now have the knowledge and experience to implement highly energy-efficient IoT devices that can operate for extended periods on standard batteries.

Kostiantyn Oliynyk

Head of IoT at Webbylab

Check out our IoT architecture strategies.

Best Practices for IoT Firmware Development

To create high-quality firmware, you should follow IoT firmware best practices. Here are the top recommendations from our experience:

Incorporate Must-Have Features

As we said, picking the right functionality is probably the most important aspect of IoT firmware development. Based on what we’ve learned from building IoT solutions, we’ve put together a list of the features you should definitely include:

Consider Additional Features

There are several nice-to-have features that can really improve the user experience and make your device more flexible. Let’s quickly go through them as well:

Leverage Open-Source Communities

When developing firmware for Intellect LED, we created three distinct versions of LED lamp firmware fully integrated with a private instance of 2Smart Cloud. This allowed for seamless synchronization and control through a mobile app.

Read also: IoT Applications Development Tips.

Our client had a business running on open-source firmware, and we needed to develop our own firmware without losing quality and functionality. It was a fascinating challenge to replicate the best practices of the open-source community and adapt the firmware for mass-market use.

Kostiantyn Oliynyk

Head of IoT at Webbylab

A printed circuit board and the Intellect LED lamp

Partner with Reliable Hardware Manufacturers

To make sure your firmware is efficient, choose the right hardware platform. We’ve found that Espressif Systems is a worthy pick. Here’s how.

We started building embedded systems with our proprietary product, Propuskator. As part of this project, we developed a line of controllers based on ESP32 microcontrollers. Why did we choose these solutions? Two reasons:

• Espressif’s native toolset offered reliability.
• ESP32 microcontrollers fully met our technical requirements.

An ESP32 microcontroller with a built-in Wi-Fi module on a breadboard

Kostiantyn Oliynyk

Head of IoT at Webbylab

Helped dozens of startups create effective IOT products.

Get a Consultation

Later on, we began to more actively engage in commercial firmware development — all based on microcontrollers from Espressif. Here are our other projects:

• MyBox: In collaboration with the client’s embedded team, we develop firmware for their products that control the EV charging process and monitor various parameters. This is not just a single product, but an entire line of devices integrated with cloud software.
• A/C drain line cleaner: We have developed and continue to enhance the firmware for a range of devices for cleaning drainage systems. A key feature of this device is its use of the ESP32 microcontroller, which allows it to operate on just four AAA batteries for several years, while still maintaining IoT connectivity and smart features.

A MyBox EV charging station

Now that you know Espressif is a solid hardware choice, you may also want to explore how to find the right IoT development partner.

Hands-On Guidelines on Arduino IDE for IoT Firmware Development

When we began developing 2Smart Cloud — a comprehensive IoT development platform — we faced the challenge of integrating devices that could natively support our protocols. 

We experimented with creating our own firmware for the ESP32 based on the Espruino framework. However, we found that working with JavaScript for tasks beyond simple LED control was restrictive. That’s why we switched to using the Arduino IDE as more flexible and beginner-friendly.

Kostiantyn Oliynyk

Head of IoT at Webbylab

How Arduino IDE Works

Arduino IDE (Integrated Development Environment) is a popular platform for creating firmware for microcontrollers like Arduino, ESP32, and AVR. It offers an intuitive interface for writing, compiling, and uploading code directly to the device. With a vast collection of libraries and examples available, even beginners can quickly start creating projects — from controlling LED lamps to building complex industrial IoT systems.

The Arduino IDE uses a simplified version of C++, making it easy to use without needing to dig into the low-level aspects of the microcontroller. Code is uploaded via USB or UART, and the platform also supports automatic code generation to initialize basic functions.

Advantages vs. Limitations of Arduino IDE

While the Arduino IDE is great for prototyping and modernization of IoT devices, it has significant limitations when it comes to commercial production and mass production of devices. Let’s look at the pros and cons:

At the time we fully adopted Arduino IDE, we were targeting enthusiasts and startups as the audience for our 2Smart Cloud product. Arduino was a perfect fit for that. We developed a basic framework to speed up development and IoT firmware analysis as well as created several devices for easy testing of both the platform and our own projects.

Key products include our fire lamp, which became an independent product, firmware versions for Sonoff relays, and a custom relay — one of the onboarding projects for the 2Smart Cloud platform. All of these products are open-source, so anyone can replicate them.

Configuring firmware in 2Smart Cloud

Additionally, for the enthusiasts in our audience, we created an integration with ESPHome, a popular firmware in the community.

Take the Next Step to Upgrade or Develop Your IoT Firmware

When handling IoT firmware development, focus on energy efficiency, security, and scalability. If you keep the must-have features we talked about in mind, you’ll set yourself up for success now and down the road.

And if you help with the evolution of firmware for IoT devices, we’ve got you covered. Just reach out to our IoT firmware development expert, and we’ll help you get your project where it needs to be.

Ready to elevate your IoT firmware? Let’s discuss your project.