ARCC

A smart cycling hardware companion app. BLE device integration that works at 30 km/h on a wet road with interference, vibration, and signal conditions no indoor test reveals. Flutter, Node.js, MongoDB. 4 months.

Timeline
4 months
Integration
BLE
Ride Data
Real-time
Platforms
iOS & Android

What We Delivered

Product Strategy UX/UI Design (Figma) Flutter Mobile App Backend API (Node.js) MongoDB BLE Hardware Integration Firebase

The Situation

ARCC had built something genuinely impressive: an Intelligent Drive Pod capable of converting a traditional bicycle into an electric-assist smart bike. The hardware worked. What they needed was a companion app that made the hardware intelligent, not just functional. And the hardest part was not the app. It was the space between the app and the hardware.

  1. BLE reliability in outdoor cycling

    Bluetooth connections in cycling environments face interference, distance variations, vibration, and device state changes that indoor testing does not reveal. A connection that holds perfectly on a desk drops at 30 km/h on a road with overhead power lines. Every reconnection scenario had to be built for conditions the lab cannot simulate.

  2. Real-time data from hardware sensors

    Ride data needed to appear on screen in real time, with the accuracy and update frequency useful during an active ride. Stale data on a cycling dashboard is not just unhelpful. It is actively misleading.

  3. Hardware-software handshake

    Device pairing, connection state management, data synchronisation, and graceful disconnection handling. When the connection drops mid-ride, the app cannot panic. It must handle the interruption without losing data or trust.

  4. Meaningful data presentation at speed

    Raw sensor data is not useful to a cyclist at speed. The app needed to transform hardware output into metrics cyclists care about, displayed at a size and contrast readable at a glance without taking eyes off the road.

The hardware was the product. The app was what made it worth using. The BLE connection was where both met the real world.

The Approach

Phase 1

BLE Architecture and Ride Context Design

Mapped the complete data flow from ARCC hardware through BLE to the mobile interface. Tested assumptions about connection reliability against actual cycling conditions.

BLE protocol design

Structured data exchange between the Intelligent Drive Pod and the mobile app, with error handling and automatic reconnection logic built for outdoor cycling. Not the Bluetooth specification. The Bluetooth reality. Vibration, movement, signal occlusion, battery state transitions. Each handled gracefully because the cyclist cannot troubleshoot while riding.

Riding context UX

Interface designed for glance-ability at cycling speed. Large, clear metrics. High contrast. No interaction required while riding. The cyclist's eyes leave the road for less than a second. Every piece of information visible in that window must be worth the glance.

Data pipeline architecture

From raw sensor output to meaningful ride metrics, every transformation stage validated for accuracy. A speed reading that lags by three seconds is not a speed reading. It is a memory.

Phase 2

Flutter App with Hardware Integration

Flutter for cross-platform delivery. BLE integration built for the conditions cycling actually creates, not the conditions a conference room simulates.

BLE device management

Pairing flow designed for simplicity. Connection state managed transparently. Disconnection handled gracefully with automatic reconnection and no data loss. The cyclist should never need to think about the connection. When it works, it is invisible. When it drops, it recovers.

Real-time ride dashboard

Live data from the ARCC device, updated at the frequency cyclists need, displayed at the size cyclists can read. Speed, distance, battery level, assist mode. Each metric positioned for the split-second glance.

Post-ride analysis

Ride data stored and presented as performance metrics, route data, and historical comparison. The ride that just ended becomes data that informs the next one.

Phase 3

Backend and Data Infrastructure

Node.js backend with MongoDB for ride data storage, processing, and device management.

Ride data processing

Backend transforming raw sensor streams into structured ride metrics with validation and error correction.

MongoDB document model

Variable ride data shapes across different hardware configurations and firmware versions, accommodated without schema rigidity.

Firebase integration

Authentication, push notifications for device status, and real-time data synchronisation.

The Numbers

Timeline
4 months
Hardware companion app delivered.
Integration
BLE
Reliable hardware integration tested in real cycling conditions.
Ride Data
Real-time
Live ride data at glance-readable speed.
Platforms
2 platforms
iOS and Android from a single codebase.

ARCC launched with a companion app that makes the Intelligent Drive Pod genuinely smart. The hardware provides the power. The app provides the intelligence. The BLE connection between them holds in the conditions that matter.

Mohit's Take

"BLE integration sounds straightforward until you test it outdoors on a bicycle. Connection behaviour indoors bears no resemblance to what happens on a road with interference, vibration, and 30 km/h movement. We rebuilt the reconnection logic three times before it handled every edge case we could simulate, and then we found new edge cases on the first outdoor ride test. Every reconnection scenario had to be built for real riding conditions, not lab conditions. That gap between 'works on the desk' and 'works on the road' is where the engineering effort lived."

— Mohit Ramani, Founder & Lead Architect, Empyreal Infotech

Tech Stack

The toolchain behind the ARCC companion app.

Flutter Figma Node.js MongoDB BLE Protocol Firebase

Start a Conversation About Your Product

You have hardware that works. You need an app that makes it intelligent. The question is whether the team building the app understands the space between the hardware and the software, where connection reliability, data accuracy, and user context determine whether the product feels smart or frustrating.

A discovery call with Empyreal is thirty minutes. You describe the hardware. Empyreal listens, asks the questions about real-world conditions that change the integration architecture, and tells you honestly what the companion app requires.