// iot and connected devices

The device passes. The app passes. The product still fails. We test the seams between them.

Connected products break in the joins: a reconnect, an update, a clock. We test the whole chain, device, radio link, app and cloud, with QA tools we built ourselves. Safety products get the same discipline in security work: ten high-severity findings in an SOS app were retested one by one.

Start a one-month trial
4 ISO certificatesReviewed on Clutch€20-45/hourone-month trial, first two weeks complimentary if not happy
// a bug I still remember
“I was testing a device scanning workflow where duplicate serial numbers were correctly blocked during scanning, so everything seemed to work. But when I edited a device that had already been scanned, I could give it the same serial number as another device without any warning. I wouldn't have caught it if I'd only tested the initial scanning flow.”
Luminita Pintilei, QA engineer, IoT
// what keeps you up at night, and what you get
"A device reconnects and sends part of its backlog twice."
Soak runs, fleet reconnection and firmware rollback tested before your users find them.Flows
"A firmware update ships and the app still expects the old format."
The whole chain tested together: device, radio link, app and cloud, across the firmware versions in the field.Flows
"Customers return the device because setup confused them."
Setup tested with people who will never read the manual, every defect logged with its device, firmware and app version.BugBoard
// four places connected products break
01 · reconnect

A device reconnects and sends its backlog twice

MQTT QoS 1 promises at-least-once delivery, not exactly-once. If the acknowledgement is lost while the link drops, the device resends the same reading after it reconnects. Without a message id and a dedupe on the cloud side, both copies are stored and the chart doubles.

also: a whole fleet reconnecting in the same second after an outage
devicebrokercloudPUBLISH 412 QoS 1deliver 412INSERT reading 412PUBACK lost, link dropsoffline 1 day, queue keptresend 412 DUP=1deliver 412 againINSERT reading 412 again
FAILreading 412 stored twice, the 24 h total is one reading too high
how we test itDrop the acknowledgement on purpose, take the device offline, bring it back. Assert one stored reading per message id and a chart that matches the device log.
await device.publish(reading(412), { qos: 1 })
broker.dropAck(412); await device.offline('24h')
await device.online(); await cloud.drain()
expect(db.count('readings', { msgId: 412 })).toBe(1)   // got 2
expect(chart.total('24h')).toBe(sum(device.log()))     // got sum + reading 412
02 · firmware update

A firmware update loses power halfway

A device that overwrites its only firmware image has no way back if power drops mid-write. It needs a way back: two slots, or a bootloader that can recover. With two slots, write the new image to the inactive slot, boot it, and mark it good only after a health check. Otherwise one flat battery in the field is a returned unit.

also: update interrupted by a dropped connection, rollback after a bad image
v2.1download
sigverified
eraseslot A
62%power cut
bootno image
BRICKEDno slot to roll back to
how we test itCut power at a different point of the update on every run, from the first byte to the last. After each cut the device must boot, on the old version or the new one.
for (const pct of [0.01, 0.25, 0.62, 0.99]) {
  await ota.start('2.1.0'); await power.cutAt(ota.progress(pct))
  await power.restore()
  expect(await device.bootsWithin('2m')).toBe(true)   // got no boot
  expect(['2.0.3', '2.1.0']).toContain(device.firmware())
}
03 · version skew

The app expects last year's message format

A fleet is never on one firmware version. Release 2.1 renames a field, and the app still reads the old name. No error is raised: the value is simply missing, and the chart goes flat at zero for every device that updated.

found when customers report that the readings look wrong
{ "dev": "a1b2", "fw": "2.1.0", "battery": 81, "temperature": { "c": 4.2 } } app 3.4 reads "temp_c"
MISSINGtemperature unread, chart flat at 0
how we test itRun every firmware version still in the field against every app version still supported, with a simulated device per version. The value that reaches the screen must equal the value the device measured.
for (const fw of fleet.versions()) for (const app of supported) {
  const msg = deviceSim(fw).telemetry()
  expect(parse(app, msg).tempC).toBeCloseTo(msg.truth, 1)
}
04 · timestamp

A reading from nine hours ago shows the time it arrived

Readings buffered while offline are stamped with the arrival time on the server, not the time the sensor measured them. The app shows a nine-hour-old value as current. Device clocks cause the same trouble from the other side: an unsynchronised RTC after a battery loss can report a date decades in the past.

also: RTC reset after battery loss, daylight saving on the device
measured at (device)06:10received at (cloud)15:10stored as15:10age shown in the app0 min
use device timeadd sync offsetflag drift over 5 min
FAIL9 h old, shown as now
PASSage = now - measured
how we test itMeasure while offline, reconnect hours later, and compare what the app shows with when the device measured. Also set the device clock wrong and check the reading is flagged, not trusted.
await device.measure({ at: '06:10' }); await device.offline('9h')
await device.online()
expect(app.reading().timestamp).toBe('06:10')   // got 15:10
expect(app.reading().isStale).toBe(true)        // got false

Illustrative examples built from defect patterns we test for. Not client data.

// on every pull request

Your code is written in hours. Our pipeline keeps up.

Pull requestfrom your coding agent
Flowsjourneys and fault injection
Security Toolkit15 scanners + 20 own checks
QA engineerconfirms every finding
BugBoardrelease report, Jira sync
// the regulation, in testing terms
regimewhere it actually breakswhat we run
EU Cyber Resilience ActObligations phase in: reporting of exploited vulnerabilities from 11 September 2026, most others from 11 December 2027update path, rollback and vulnerability handling exercised, not just documented
ETSI EN 303 645No universal default passwords, updates that never install, readings sent unprotectedpairing and credential tests, update tests, traffic inspection
Radio Equipment DirectiveDelegated act on cybersecurity applies from 1 August 2025, mainly to internet-connected radio equipmenttest evidence for network protection, privacy and fraud requirements
GDPRLocation and health readings stored or logged longer than neededdata-flow checks, retention and deletion tests, log scans for personal data
// proof

Connected products we have tested

Owletcold-chain monitoringfirmwareBluetoothunreliable networks
  • Owlet, baby health monitoring: data sent over unreliable networks, very sensitive data, long use, setup for tired parents.
  • Cold-chain monitoring for pharmaceuticals: firmware, Bluetooth, and readings that match what the device measured.

Cold-chain client name withheld. We produce the test evidence for your conformity assessment.

BUG-0731 · device sync / app · examplehigh

Reconnect after a day offline counts readings twice

  1. Take a device offline for 24 hours with readings queued
  2. Reconnect it and cut the link while the backlog is being sent, before any acknowledgement arrives
  3. The device resends the unacknowledged backlog and the app counts each of those readings twice

Fix: Send a message id with each reading and ignore ids already stored.

MQTT QoS 1REQ-SYNC-04TC-0922 addedJira IOT-418

A one-month trial on your device, app and cloud. The first two weeks are complimentary if you're not happy.

Start a one-month trial
// in depth: the long version
// 01

What we test

  • The device and its firmware. Functional behaviour, firmware updates and rollback, power loss in the middle of a write, and long soak runs that find the leak a one-day test cannot. For the deeper firmware work, see embedded software testing.
  • Connectivity. Pairing, weak signal, dropped links and, above all, what happens on reconnect: is queued data sent once, twice or never? Bluetooth Low Energy, Wi-Fi and cellular each fail differently, so we test the ones your product uses.
  • The companion app. Setup and pairing, live readings, alerts and notifications, on a real matrix of phones and operating system versions. See mobile app testing.
  • The cloud and its APIs. Device-to-cloud messages, the APIs the app depends on, and whether the data that arrives is the data the device sent. See API testing.
  • Security and privacy. How devices pair and authenticate, what travels unencrypted, what the APIs expose, and how personal data is handled under GDPR. See our penetration testing services.
  • Load and reliability. Thousands of devices reporting at once, a fleet reconnecting in the same second after an outage, and behaviour over weeks rather than hours. See performance testing.
  • Compatibility across versions. A fleet is never on one firmware version. The app has to work with the current release, the previous one and whatever an old batch is still running.
  • Setup for real people. The out-of-box experience is where most returns start. See usability testing.
// 02

Where connected products actually break

A laptop open on a desk with several phones beside it and a cup of coffee, seen from above

The device passes. The app passes. The product still fails, and the user blames the device.

The app shows a reading from nine hours ago with today's timestamp. A device that was offline for a day reconnects and sends its backlog twice, so the chart doubles. A firmware update succeeds and the app still expects the old message format. None of these shows up when each team tests its own layer, which is why we test the seams between them on purpose.

// 03

Work we have done

Cold chain monitoring. Devices that track temperature and humidity for industries such as pharmaceuticals. We tested the firmware, the Bluetooth connectivity and whether the readings that reached the system matched what the device measured.

Baby care health monitoring. Devices sending a baby's health readings to a parent app in real time. We tested data transmission under unreliable networks, the security of very sensitive data, endurance under long use, and a setup flow that had to work for tired parents who are not technical. We brought in simulators to reduce dependence on physical devices, and ran two bug scrub meetings per sprint so problems were triaged early.

More detail in how we adapt testing for IoT devices and IoT in healthcare.

// 04

How we work without owning your hardware

If units can be shipped to Cluj-Napoca, that is simplest, and it is what we would usually propose. Where you have a rig or a lab, we design the tests and your engineers run the hardware. Where devices are scarce, we use simulators and emulators for the device side and test directly against the app, the APIs and the cloud for everything above it.

Every defect is reported with the device model, firmware version, app version and phone it happened on, plus the logs, because an IoT bug without its versions cannot be reproduced. Test cases and results live in BugBoard, so you can trace each requirement to the test that covers it. Where it pays off, we automate the app and API regression with Flows.

// 05

What it costs

€20-45per hour

€20 to €45 an hour.

The rate moves with the seniority of the engineer, how long you commit for, and the mix of manual, automation and specialist work. Longer commitments move down the range. Our tools come with the engagement, with no separate licence cost.

An engineer can be working on your product in about two weeks. We start the same way on every engagement: a one-month trial, and the first two weeks are complimentary if you are not happy with what we deliver.

// 06

Why us

Colleagues working on laptops around a long table in the BetterQA office

We are independent. We did not build the device, the app or the cloud, so we have no reason to assume the layer we did not write is someone else's problem.

We built our own tools. BugBoard for test management and traceability, Flows for automation, Auditi for WCAG, GDPR and FDA auditing, BetterFlow for visibility into the hours, and our AI Security Toolkit. They come with the engagement.

Four ISO certificates, all current: ISO 9001:2015, ISO/IEC 27001:2022, ISO 13485:2016 and ISO 14001:2015. ISO 13485 matters if your device is a medical one.

Reviewed on Clutch. Written by clients, not by us. Founded in 2018, 50+ engineers.

// 07

Common questions

Do you need our devices?

Ideally, yes: a handful of units shipped to Cluj-Napoca is the simplest setup. If that is not possible, we work with your rig remotely or use simulators for the device side and test the app, APIs and cloud directly.

Which connectivity do you test?

Whatever your product uses. Bluetooth Low Energy, Wi-Fi and cellular come up most often. Tell us yours on the first call and we will say how we would test it.

How is this different from embedded software testing?

Embedded testing goes deep on the firmware. IoT testing covers the whole system: device, connectivity, app, cloud and the seams between them. Most connected products need both, and we scope them together.

Do you include security testing?

Yes. Pairing, authentication, data in transit and the APIs behind the app are part of the test plan, and our AI Security Toolkit comes with the engagement.

How soon can you start?

About two weeks to have an engineer working on your product. The first month is a trial, and the first two weeks are complimentary if you are not happy with what we deliver.

Talk to us

Tell us what the device does, how it connects, how it gets updated, and what the last field failure was. We will tell you which layer we would test first.