ChecklistLaunchHardware

Developer Checklist: Shipping a Companion App for a CES-Worthy Gadget

UUnknown

2026-02-23

10 min read

A focused pre‑launch checklist for hardware startups demoing at CES—connectivity, demo flows, analytics, privacy, and CI/CD tips for React Native teams in 2026.

Hook — Shipping a CES demo shouldn’t feel like praying to a router

CES is unforgiving: crowds, flaky Wi‑Fi, 30‑second attention spans and investors who expect a working product on the show floor. For hardware startups that pair a gadget with a React Native companion app, those conditions amplify the usual pre‑launch anxieties: connectivity that drops mid‑demo, analytics that don’t capture conversion events, privacy requirements that bite at the last minute, and an App Store submission that stalls your launch timeline. This checklist gives you a focused, practical path to ship a CES‑worthy companion app with confidence — with clear devops integration, automation, and tips tuned for 2026 realities like Matter, UWB adoption, and stricter privacy disclosures.

Top‑level checklist (read first)

Before you dive into the sections below, commit these non‑negotiables now. Treat them as gates for a CES demo build:

Stable connectivity patterns for BLE, Wi‑Fi provisioning, and fallbacks (SoftAP, QR, cloud).
Deterministic demo flows — scripted, seeded, and offline‑capable.
Observability — crash reporting, remote logs, and live telemetry dashboards.
Privacy & compliance — data minimization, consent UI, App Store/Play privacy forms filled.
Automated CI/CD for builds, tests, and runway for last‑minute fixes (Fastlane/EAS/GHA).

Why 2026 matters: trends that change the checklist

Recent shifts matter for CES demos:

Matter and smart home convergence: By 2026 Matter is common in consumer device stacks — supporting cloud/local discovery and standardized provisioning changes the connectivity surface you must test.
UWB adoption: Ultra‑wideband is common in proximity features; coordinate testing across iOS/Android SDK differences.
Stricter privacy labels & store checks: App privacy disclosures, data deletion workflows, and runtime consent are enforced more strictly than in 2023–24.
Edge ML & on‑device processing: Many demos use on‑device inference to avoid network dependency — plan model packaging and size limits in the binary.

Connectivity Checklist — make your gadget and app talk reliably

Connection failures are the single biggest demo killer. Cover all realistic scenarios and provide deterministic fallbacks.

1. Supported flows

Implement and test all provisioning options you advertise: BLE provisioning (GATT), SoftAP (Wi‑Fi access point), QR + cloud token, and Matter/Thread commissioning.
On Android, test BLUETOOTH_CONNECT, BLUETOOTH_SCAN, and NEARBY_WIFI_DEVICES permissions on Android 12+ and Android 13+ behavior changes.
On iOS, request & handle Bluetooth and Local Network entitlements properly. Validate Local Network permission flow (iOS 14+) for LAN discovery.

2. Reconnection and edge cases

Implement exponential backoff and explicit reconnect UI. Avoid silent retries that spin the radio and drain battery.
Provide a visible device status, RSSI, last‑seen timestamp and a way to force rediscovery.
Test with multiple devices in the same airspace — common at CES booths — to catch name collisions and race conditions.

3. Firmware updates and signing

Use signed firmware bundles and validate server signatures in the app. Provide a revert plan in case an update bricks a device during the show.
Support a local DFU mode (USB or BLE) for emergency recovery on the booth floor.

4. Diagnostics and remote assistance

Embed verbose diagnostics toggled by a debug flag: connection logs, last GATT interactions, network traceroute to your cloud endpoints.
Expose logs over an ad‑hoc HTTP endpoint on the device for quick collection by engineers.

Demo Flows — scripted, repeatable, demo‑proof

A CES demo must be short, surprising, and reliable. Build demo flows that are resilient to the noisy show environment.

1. Scripted happy path and plan B

Create a 20–45 second happy path for a non‑technical audience (investor, press) and a longer technical flow for deep demos.
Design a local, offline demo mode with seeded data so no cloud dependency is required. Include a toggle in a hidden dev menu.

2. Demo accounts & seeded hardware

Use pre‑provisioned demo devices with known firmware and authenticated test tokens. Label them physically and in the app UI.
Seed user data and pre‑cache assets so the first interaction is instant (images, models, audio).

3. Fake devices and simulators

Implement a Device Simulator Mode in the app that can simulate sensor streams and error conditions. This reduces dependency on physical devices for last‑minute dry runs.

Analytics & Observability — ship with actionable telemetry

At CES you need both a polished experience and real data to follow up. Instrument for conversion, not just page views.

1. Events that matter

Track demo funnel events: discovery → connect attempt → successful pairing → key feature interaction → share/CTA.
Capture failure events with contextual data (device id, firmware version, signal strength, stack traces) to triage quickly.

2. Tools & SDKs

Use lightweight analytics SDKs compatible with React Native: Amplitude, Mixpanel, Segment, or Firebase Analytics. For error tracking use Sentry or Firebase Crashlytics.
Consider serverless edge collection to reduce latency and protect PII. Batch events and upload on stable connectivity.

3. Live dashboards and alerting

Build a minimal live dashboard showing number of current connections, success rate of pairing, and crash rate. Hook alerts (Slack/PagerDuty) for spikes in errors.
For CES, put a TV or tablet with the dashboard at the booth so the team can watch in real time.

Privacy & Data Handling — ship safely under scrutiny

Privacy missteps are high visibility at CES. Make consent obvious, and default to minimal data collection during demos.

Make the demo mode opt‑in with a clear banner: “This demo collects anonymous telemetry to improve product demos. No personal data is collected.”
Disable background analytics and crash reporting on demo devices by default. Or route demo telemetry to a separate environment.

2. Store requirements & forms

Complete Apple’s App Privacy details and Google Play Data Safety form before submitting. In 2026 these forms are reviewed more strictly — avoid last‑minute rejections.
Prepare a public privacy policy and an internal data retention plan for demo telemetry (e.g., auto‑delete logs after 30 days).

3. Security basics

Use TLS everywhere. Pin server certificates for critical firmware downloads or pairing tokens.
Store secrets in secure keychains (iOS Keychain / Android Keystore). Don’t hardcode API keys in the binary.
Sanitize logs: never print PII to debug logs that are collected in analytics or remote logging.

App Store & Deployment — avoid last‑minute blocks

Submission delays are common. Automate as much of the release pipeline as you can and prepare for store review questions in advance.

1. Build pipelines and signatures

Use CI for reproducible builds. For React Native teams, common setups in 2026 include GitHub Actions + Fastlane, or EAS (Expo Application Services) if you use Managed or Bare Expo workflows.
Automate code signing and provisioning: Fastlane match or Google Play App Signing. Store credentials in a vault (AWS Secrets Manager, GitHub Secrets).

2. TestFlight & internal tracks

Populate TestFlight groups and Google Play internal testing early. Push a “CES candidate” build to internal testers at least two weeks before the show.
Use phased rollouts on the Play Store to reduce blast radius for any last‑minute bugs.

3. Store artifacts & marketing assets

Prepare screenshots and a 15–30 second demo video optimized for phone and tablet product pages. Highlight the single, compelling feature you want to convert visitors on.
Write App Store metadata tailored to CES audiences: brief technical callouts for press/partners and simple benefit text for consumers.

CI/DevOps Integration — put it on rails

Automation reduces show‑floor firefighting. Integrate builds, tests, deployments and observability into a single flow.

1. Recommended pipeline

PRs trigger unit + lint + type checks (ESLint/TypeScript).
Merge triggers E2E test matrix (Detox/Appium) against emulator and a device farm (Firebase Test Lab or private pool).
Passing builds create an artifact and trigger Fastlane/EAS to produce TestFlight & Play internal builds.
On release, trigger a staged rollout and notify Slack with build links and release notes.

2. Example: fastlane lane (conceptual)

lane :ces_candidate do
  increment_build_number
  run_tests # unit + e2e
  build_app(scheme: 'Release')
  upload_to_testflight
  supply(track: 'internal', apk: 'app-release.aab')
  notify_slack(message: 'CES candidate build ready')
end

3. OTA updates and policy

Integrate OTA updates (CodePush or EAS Updates) for UI tweaks but follow platform rules: don’t change the binary’s primary purpose post‑review.
Whitelist demo devices/teams for aggressive OTA channels and keep production channels stable.

Testing Matrix — don’t trust a single phone

Test on varied hardware and OS versions. CES attendees will use phones across vendors and OS builds.

At minimum: recent iPhone models (with UWB if used), Android flagship and midrange devices, tablet.
Test in low‑bandwidth conditions and with captive portals common at trade shows.
Use device farms for parallel regression; maintain a small on‑site device lab for the last mile.

On‑site logistics — what to bring to CES

Pack a kit for unrehearsed failures:

Multiple standby phones/tablets with pre‑installed debug builds and fully charged power banks.
Local Wi‑Fi router with a separate demo SSID and preconfigured DHCP for captive portal avoidance.
USB‑serial adapters and spare cables for quick firmware flash/serial logs.
A printed checklist for the booth staff with quick recovery steps.

Small code example: request Bluetooth + Local Network permissions (React Native)

Shareable snippet to ensure you ask permissions early and handle rejections gracefully.

import { BleManager } from 'react-native-ble-plx';
import { request, PERMISSIONS, RESULTS } from 'react-native-permissions';

async function requestConnectivityPermissions() {
  // iOS
  await request(PERMISSIONS.IOS.BLUETOOTH_PERIPHERAL);
  const localNet = await request(PERMISSIONS.IOS.LOCAL_NETWORK);
  if (localNet !== RESULTS.GRANTED) {
    // show a clear UX explaining why Local Network is needed
  }
}

function startScan() {
  const manager = new BleManager();
  manager.startDeviceScan(null, null, (err, device) => {
    if (err) { console.error('BLE scan error', err); return; }
    console.log('found', device.id, device.name);
  });
}

Real‑world note: a CES near miss (short case study)

At CES 2025, a startup’s demo app repeatedly failed to discover devices on the booth Wi‑Fi. The fix: switch the demo to preconfigured SoftAP provisioning and route all analytics to a separate dev project. They reclaimed demos within hours and captured conversion metrics separate from production. Lesson: have an offline contingency and segregated telemetry.

Post‑CES followup — turn demos into product momentum

Export demo analytics and map it back to lead lists. Instrument a “follow up” event to know which demo visitors clicked a CTA.
Open issues for any device/firmware failure observed and prioritize fixes that unblock adoption pathways.
Run a postmortem on the demo flow and automate any manual steps used at the booth.

Actionable takeaways

Build an offline demo mode now — it will save you at the show.
Segment analytics so demo telemetry doesn’t pollute product metrics and so you can track demos separately.
Automate CI/CD with a CES pipeline that produces a predictable “CES candidate” build you can roll back to.
Prepare a recovery kit (spare devices, router, offline firmware) and a 1‑page recovery checklist for booth staff.

Final Checklist (printable 1‑page)

Connectivity: BLE/GATT, SoftAP, QR/cloud, Matter tested.
Demo: 30s happy path, offline demo mode, seeded devices.
Analytics: funnel events, separate demo stream, live dashboard.
Privacy: consent banner, privacy policy, App Store / Play forms completed.
CI/CD: reproducible builds, TestFlight/internal tracks, code signing automated.
On‑site: spare devices, local router, cables, printed recovery steps.

Closing — ship a demo that opens doors, not bug reports

CES is an irreplaceable stage for hardware startups. With the right pre‑launch checklist — focusing on connectivity resilience, deterministic demo flows, observability, and airtight privacy — you reduce risk and create repeatable moments that convert. In 2026 the bar is higher: Matter, UWB and stricter privacy policies mean you must be deliberate about integration and compliance. Follow this checklist, automate your pipeline, and leave room for contingency. Your demos should sell your vision, not your debugging skills.

Call to action

Ready to lock your CES build? Download our ready‑to‑fork React Native demo starter (with BLE, offline demo mode, analytics, and Fastlane + GitHub Actions pipeline) or contact our team at reactnative.store for a review of your CES candidate build. Ship confidently — and make every demo count.

Unknown

Contributor

Senior editor and content strategist. Writing about technology, design, and the future of digital media. Follow along for deep dives into the industry's moving parts.