Edge IoT · Camera-free wellness monitoring
BlindSense
Sense without seeing.
Camera-free elderly wellness monitoring: WiFi CSI and 60 GHz mmWave radar fused on-device, Rust services on AWS, a real-time dashboard and an iOS app.
- Role
- Global Crown Digital product · architecture and engineering end to end: firmware, cloud, web and iOS
- Organization
- Global Crown Digital Corporation · pre-launch, waitlist open
- Timeframe
- March 2026 – Present
- ESP-IDF v6 (C)
- ESP32-S3/C5/C6
- WiFi CSI
- 60 GHz mmWave radar
- AWS IoT Core (MQTT/TLS)
- Rust on Lambda
- DynamoDB
- EventBridge + SNS
- AWS CDK
- Amazon Bedrock (Claude)
- Next.js
- SwiftUI + APNs
Wellness monitoring, not a medical device or an emergency alarm.
Context
BlindSense is GCDC's own product: wellness and activity monitoring for older adults, with no cameras, no microphones and no wearables. Its public line is "Quiet care, without the compromises." The product rules out all three. Sensing therefore had to come from WiFi channel state information (CSI) and 60 GHz mmWave radar, packaged as two small wall-mounted boxes per room. Anything critical had to be decided on the device, never in the cloud. An LLM could describe what the system sensed, but never be the thing that decided. The positioning had to stay honest: wellness monitoring, not a medical device, not an emergency alarm. And one engineer had to carry it from firmware to the iOS app.
What we built
Firmware: C on ESP-IDF v6, ESP32-S3/C5/C6.
Real-time WiFi CSI capture and multi-sensor fusion with the 60 GHz mmWave radar run in firmware on a multi-node ESP32 kit. Critical decisions are made on the device, never in the cloud, so none of them waits on a network round-trip.
Per-device X.509 identity and OTA A/B updates.
Each device holds its own X.509 certificate and authenticates to AWS IoT Core over TLS. Firmware is delivered by OTA A/B updates.
Ingestion: AWS IoT Core to Rust on Lambda.
Devices publish MQTT over TLS to IoT Core, which hands messages to Rust Lambda services that persist to DynamoDB and fan out through SNS and EventBridge.
Deterministic engine decides, Bedrock narrates.
A deterministic stats engine computes activity and wellness flags. Amazon Bedrock (Claude) is permitted only to narrate flags that already exist, and claim-lint guardrails check the narration against those flags. The model never decides and never invents a flag; take it away and every flag still stands.
Next.js real-time dashboard on SigV4 MQTT over WebSocket.
The dashboard subscribes to IoT Core directly over a SigV4-signed MQTT over WebSocket connection, so live telemetry, including a 3D radar point cloud, streams to the browser.
SwiftUI iOS app with APNs from Rust.
Push notifications are signed ES256 and sent to APNs over HTTP/2 directly from the Rust backend, with no push vendor in between: one fewer party in the path and one fewer dependency to outlive.
The whole backend in AWS CDK.
IoT Core, Lambda, DynamoDB, SNS and EventBridge are declared in CDK, so the backend can be diffed before it changes and rebuilt from scratch.
Outcome
None
cameras, microphones or wearables
60 GHz
mmWave radar fused with WiFi CSI, on the device
On-device
every critical decision, never in the cloud
Rust
Lambda services behind IoT Core; APNs signed ES256 over HTTP/2
- The whole stack, engineered end to end: ESP-IDF firmware on a multi-node ESP32 kit, Rust services behind AWS IoT Core, a Next.js real-time dashboard and a SwiftUI iOS app with push.
- Pre-launch, stated plainly: BlindSense is coming soon, with the waitlist open at blindsense.ca. Wellness and activity monitoring, designed in Canada; not a medical device, not an emergency alarm.
- A reusable decision boundary: deterministic logic decides, the LLM narrates, claim-lint guardrails sit between. This is the pattern we recommend wherever a model is being asked to sit near a decision.
Engineering notes
Two signals, one decision point
WiFi CSI comes from radios the ESP32 kit already carries; the 60 GHz mmWave radar adds a 3D point cloud. Fusing them in firmware costs a harder embedded problem, real-time CSI capture and multi-sensor fusion in C on ESP-IDF v6, but it buys the property that matters: the decision is made where the data is and never waits on the cloud. Firmware is delivered by OTA A/B updates.
Security follows the data
There is no video and no audio, so there is no video or audio to secure. Each device carries its own X.509 certificate and speaks MQTT over TLS to AWS IoT Core. The dashboard authenticates to IoT Core with SigV4. APNs requests are signed ES256 over HTTP/2 from Rust. Each hop has its own identity mechanism.
The LLM sits downstream of every decision
The deterministic stats engine computes the flags. Amazon Bedrock (Claude) turns flags into plain language. Claim-lint guardrails check that the narration says no more than the flags support. If the model is slow, wrong or unavailable, the flags are unaffected, because they were computed before it was called. Operationally, the backend is IoT Core, Lambda, DynamoDB, SNS and EventBridge declared in CDK: managed services with no servers to patch, which is what lets one engineer run the whole stack.
Relevant if
Edge-to-cloud IoT. ESP32/ESP-IDF firmware with per-device X.509 identity and OTA A/B updates, MQTT/TLS into AWS IoT Core, an event-driven backend (Lambda, DynamoDB, SNS, EventBridge) you can diff in CDK, and a real-time web dashboard or native iOS app on the same stream.
Rust on AWS. Lambda services in Rust for telemetry parsing, persistence and outbound integrations such as APNs over HTTP/2: small binaries, strict types, infrastructure as code.
An LLM that explains but must not decide. Deterministic logic in front, Amazon Bedrock behind it, claim-lint guardrails between, so the model can be removed without changing a single outcome.