The most cost-effective approach is usually:

1) Use the companion app as the OTA delivery layer

Have the app fetch firmware from your backend and push it to devices over Bluetooth/Wi‑Fi/USB. This avoids building a custom update pipeline per device and lets you reuse one app/backend for the whole peripheral family.

2) Centralize firmware hosting and versioning

Store firmware binaries in a simple object store or CDN with:

• versioned files
• device-model targeting
• rollout rules
• checksum/signature verification

This keeps infrastructure cheap and scales well as the product line grows.

3) Use delta updates only if firmware is large and updates are frequent

For many peripherals, full-image OTA is actually cheaper operationally than managing binary diffs. Delta updates save bandwidth, but add:

• tooling complexity
• more failure cases
• harder support/debugging

A good rule:

• small firmware / infrequent updates → full image OTA
• large firmware / frequent updates → consider delta updates

4) Bundle update logic into a shared SDK

If you have multiple apps or white-label partners, create a reusable update SDK that handles:

• device discovery
• compatibility checks
• download/resume
• transfer protocol
• verification
• rollback/retry

This is cheaper long-term than custom update code in each app.

5) Make the device do the minimum necessary

To keep device BOM and engineering cost down:

• keep bootloader simple but robust
• support signed firmware validation
• include fallback/rollback partition if possible
• avoid expensive always-on connectivity unless needed

6) Roll out updates in stages

Use staged rollout in the backend:

• internal/devices first
• small percentage of users
• expand after error monitoring

This reduces support cost from bad releases.

7) Pick the right transport per product class

• Bluetooth LE: cheapest for low-power accessories, but slower
• Wi‑Fi: better for larger images or frequent updates
• USB: most reliable for setup/service tools, but less seamless

For a growing peripheral line, many companies use one backend + one app + multiple transport modules.

Best low-cost architecture

Device boots → app checks backend for target firmware → app downloads file → app transfers OTA → device verifies signature → device reboots into new firmware → app reports success/failure.

This is usually the best balance of:

• low cloud cost
• low app complexity
• reusable across products
• manageable support burden

What to avoid

• Building a separate update system for every device model
• Relying on app store updates for firmware delivery
• Using delta updates too early
• Skipping rollback/signature checks
• Hosting binaries ad hoc without version control or analytics

If you want, I can also give you:

1. a reference architecture,
2. a cost comparison of BLE vs Wi‑Fi OTA, or
3. a vendor/platform shortlist for companion-app firmware delivery.