When an IoT project runs late, the delay can usually be traced back to a handoff. Boards show up after the app team was supposed to start testing on them, or the firmware gets built against a version of the protocol that changed on the app side a month earlier, and nobody notices until the pilot.
Below is the IoT application development process as we run it on the connected products we build, stage by stage, with a short list at the end of each one of what should be settled before going further. If you’re the person on the client side who signs off on each step (usually a product owner or an engineering lead), this is mostly for you.
Why IoT Projects Don’t Run on a Software Timeline
On a pure software project, a bug that ships in the morning can be fixed by the afternoon, and most users will never know it existed.
Hardware changes the math. A new board revision means ordering parts and waiting for them, on a schedule your team doesn’t fully control. Once firmware is running on thousands of devices in the field, updating it means going over the air, carefully, with a way to recover if the update dies halfway through.
Then there’s radio certification. Most Wi-Fi and Bluetooth products need FCC equipment authorization before they can be marketed in the US. Canada runs its own certification program through ISED, and once a product is approved, changes to it have rules of their own.
So the logic behind the stages below is pretty simple: decisions that are slow and expensive to reverse get locked early, while the app and the cloud, which can change quickly, stay flexible as long as possible. The technical map of what you’re building, the five layers of an IoT application, has its own guide; here we’re looking at the order things happen in.
The 6 Stages of the IoT Application Development Process
Teams give these stages different names, and that’s fine. The part we’d insist on is that each one closes with a decision someone has written down.
Stage 1: Discovery and Feasibility
Discovery is mostly about the field. You want to know where the devices will be installed and what powers them, whether there’s Wi-Fi on site or cellular coverage or nothing usable, who handles the device over its life and which phone they’ll have in their pocket when they do.
Those answers ripple through every later stage. A sensor bolted inside a steel cabinet in a basement and a wearable on a wrist have very little in common once you get past the marketing slide.
It’s also the moment to find out whether the hardware is still open. When a client arrives with a device that already exists, the project starts from its constraints. That’s how the Bluetooth Mesh device manager we built for ABB began: the mesh technology was already in place on their end, and we opened with a three-day co-creation workshop with their team so that interface decisions would come from how installers and building managers really work.
Before you move on:
- Field conditions written down (installation sites, power, connectivity on location)
- Each user role listed with what that person needs the app to do
- A clear answer on whether the hardware is already decided or still open
- Who owns firmware, cloud and app, and who breaks the tie when they disagree
- The single risk most likely to sink the project, named out loud
Stage 2: Proof of Concept on Real Hardware
The point of a proof of concept is to test the weakest link under conditions close to real ones, and only that.
What counts as the weakest link varies a lot. On one product it’ll be Bluetooth range through two concrete walls; on another, battery life at the reporting frequency the business asked for, or provisioning on a five-year-old Android phone surrounded by busy 2.4 GHz networks. Development kits are fine for this. Keep the scope small and assume the code goes in the bin afterwards, because PoC code that quietly makes its way into production usually drags its shortcuts along for years.
Before you move on, a quick sanity check: had the test failed, would anything in the plan have changed? When nobody can say what, the PoC probably confirmed something the team already knew.
Stage 3: Architecture and Interface Contracts
Clients tend to underestimate this stage of the IoT application development process, and it’s the one that decides how smooth the next three will be.
What comes out of it is an interface contract between firmware, cloud and app, a versioned document describing exactly how they talk to each other: Bluetooth services and characteristics, MQTT topics or API endpoints, payload formats, error codes. With that in hand, the teams can work in parallel without guessing what the others are doing. We’ve gone into more detail on how the mobile side of an IoT system is structured elsewhere.
Two topics also belong here, even though everybody wants to push them to later. One is compatibility between app and firmware versions, since your users will never all update at the same time. The other is security, from device identity and key storage to the way firmware images get signed. Bolting either onto a product after launch costs a lot.
Before you move on:
- Interface contract written, versioned, with one owner
- A rule for which app versions support which firmware versions
- Device identity, key storage and firmware signing decided
- Over-the-air update path designed, including the case where an update fails midway
Stage 4: Parallel Development and Integration Milestones
Firmware, backend and app now move forward at the same time, each working against the contract. Where projects get into trouble is when those tracks stay apart too long. We put integration dates on the calendar from the first week, with real devices, a current firmware build and the latest app on the same bench, because the first integration session always surfaces problems and it’s much cheaper to have them early.
Keeping the tracks aligned is a topic on its own, covered right after the stages.
Before you move on:
- Integration dates in the plan, each with a named owner
- A device simulator the app and backend teams can use while hardware is late
Stage 5: Field Pilot With a Small Fleet
Lab results are optimistic by nature. During a pilot, installers use their own phones, devices end up behind metal doors, and the site Wi-Fi is shared with forty other networks.
We’d pick at least one pilot site precisely because it’s difficult. A friendly site with perfect coverage mostly tells you what you were hoping to hear. Track provisioning success, install time, support requests and battery drain, and settle, before the first device ships, which numbers mean the pilot passed.
Before you move on:
- Exit criteria agreed before the pilot starts
- At least one site picked for how hard it is
- Device and app logs reaching the team without anyone driving out to collect them
- A recovery plan for devices that a bad pilot build leaves unusable
Not sure which stage your project is really at?
Stage 6: Production Rollout and Long-Term Support
Rolling out in waves gives you a chance to catch a problem while it only affects a few customers, which is a good reason not to ship to everyone on the same day.
After that, the job is keeping a live fleet healthy. Part of it is updating firmware through the mobile app for devices that can’t reach the cloud by themselves. Another part is handling configuration across a growing fleet without visiting every site.
And somewhere in the budget there needs to be room for the yearly iOS and Android releases, which can change how your app is allowed to talk to devices. Android 12, for example, split Bluetooth access into separate runtime permissions for scanning, connecting and advertising. An IoT app with no maintenance budget starts to degrade the day it ships.
Before launch, try answering this: who gets the call when a device stops reporting on a Saturday? If the room goes quiet, Stage 6 isn’t done.
Keeping Hardware, Firmware and App Teams in Sync
Most of the friction in an IoT application development process comes from the tracks running on very different clocks. A board revision can take weeks or months, a good firmware team releases a build every week or so, and the app and backend may change several times a day. Left to itself, the fastest team ends up building on assumptions the slowest one hasn’t confirmed.
The simplest safeguard is to treat the interface contract from Stage 3 as the only source of truth. Any change goes through its owner, gets a new version number and is announced to everyone before a single line of code depends on it. Teams sometimes find that heavy at first, until the first week it saves them.
A device simulator helps a lot too. It’s a small piece of software that behaves like the device and speaks the contract, so the app team can build pairing screens, error states and edge cases long before boards exist, then reuse it later for automated tests that would be tedious with physical hardware.
Real devices belong on the app developers’ desks as well, and not only in the firmware lab. Some Bluetooth issues are hard to reproduce without a real device and a real phone, and the developer who has to fix them shouldn’t need to file a ticket and wait for hardware.
One more habit that pays off later: a simple table of which firmware build was tested with which app build. When a field issue shows up six months after launch, it’s often the quickest way to the cause.
Best Practices That Keep an IoT Project on Schedule
Leave room in the schedule for a second board revision. Betting that the first board will be the final one is a risk worth avoiding.
Certification applies to the product you actually sell, so it naturally lands late in the plan. That’s exactly why it should be booked early, rather than finding out the week before launch how long it takes.
Test on the phones your users actually carry, which won’t always be recent flagships.
Somebody, six months in, will ask why the device reports every fifteen minutes instead of every five. A short decision log means you can answer with something better than “we talked about it at some point.”
Last thing, and it happens more often than you’d think: pilots that quietly turn into production. If pilot devices stay in the field, they need the same update path and monitoring as the rest of the fleet, or a replacement plan.
FAQ
Can the mobile app be built before the hardware is ready?
Most of it, as long as the interface contract exists and the team develops against a device simulator. Anything tied to the radio has to wait for real hardware: timing, range, reconnection, pairing on actual phones. Expect a round of adjustments once the boards arrive.
Do you always need a proof of concept for an IoT project?
Not always. If the device is already in production and the work is a new or replacement app, a short technical spike on the existing protocol is usually enough. With a new device or an unusual radio environment, though, skipping the PoC tends to get expensive during the pilot.
Who should own an IoT project on the client side?
Ideally one person with authority over hardware and software decisions alike. When firmware reports to one director and the app to another, integration conflicts sit there unresolved while the calendar keeps moving. They don’t need deep expertise in every area, just the final word.
If you’re planning the IoT application development process for a connected product and would like a partner who has already been through the integration part, our IoT team works on these projects from the first workshop through long-term support.