This is a submission for the Presage SmartSpectra SDK Challenge.
PulseFlow: Turning a Webcam into a Real-Time Human-Sensing Experience
Your body, in real time.
What if exploring your body's physiological signals didn't require a smartwatch, fitness tracker, or specialized hardware?
What if all you needed was a webcam?
That question inspired me to build PulseFlow, a Windows desktop application powered by the Presage SmartSpectra SDK that turns ordinary camera input into a real-time human-sensing experience.
PulseFlow combines contactless heart rate and breathing rate estimation with live charts, guided breathing sessions, and meaningful session summaries.
I wanted to explore how complex physiological sensing technology could become a simple, approachable, and privacy-conscious desktop experience.
What I Built
I built PulseFlow, a desktop application developed with Electron, Node.js, TypeScript, and Presage SmartSpectra.
The application uses a standard webcam to estimate physiological signals and presents them through a minimal interface designed for clarity and ease of use.
Rather than building only a technical monitoring dashboard, I wanted to create an experience that people could interact with.
PulseFlow has three main components:
1. Real-Time Physiological Monitoring
PulseFlow requests two physiological measurements from SmartSpectra:
- Heart Rate: Estimated pulse in beats per minute (BPM).
- Breathing Rate: Estimated respiratory frequency in breaths per minute (br/min).
The application displays accepted readings through live numerical indicators and time-series charts.
Users can also see camera status, signal availability, and feedback when capture conditions need improvement.
2. Guided Breathing
I wanted users to do more than simply observe their measurements.
PulseFlow includes a guided breathing experience with:
- Configurable inhalation and exhalation durations.
- A minimal animated breathing indicator.
- Start, pause, resume, and end controls.
- A synchronized session timer.
- Physiological measurement collection during the exercise.
The breathing animation is driven by the exercise timer, not by artificially generated physiological measurements.
3. Session Summaries
At the end of a session, PulseFlow provides a summary containing:
- Total session duration.
- Average observed heart rate.
- Average observed breathing rate.
- Number of valid samples for each signal.
- Session completion status.
These statistics are calculated from accepted SmartSpectra measurements collected during the exercise.
Design Philosophy
PulseFlow follows a minimalist, monochromatic design direction influenced by modern developer tools and the Geist design language.
The interface emphasizes readable physiological metrics, subtle borders, restrained animations, real-time charts, and contextual notifications.
My goal was to make complex sensing technology feel understandable without overwhelming the user.
Real Measurements, Not Simulations
An important requirement I set for myself was that PulseFlow should not fabricate physiological readings.
During a live test, SmartSpectra successfully provided measurements including:
| Signal | Observed Value |
|---|---|
| Heart rate | 83.7 BPM |
| Breathing rate | 7.2 breaths/min |
These values came from an actual demonstration rather than hardcoded data.
When valid measurements are unavailable, the application displays an appropriate waiting state instead of inventing readings.
Demo
I recorded a demonstration showing PulseFlow running with a real webcam and the Presage SmartSpectra SDK.
The video showcases live physiological monitoring, the guided breathing experience, and a completed session summary.
Watch the full demonstration on YouTube
For privacy, the public recording uses anonymized camera imagery while preserving the live physiological measurements displayed by the application.
Code
The complete source code is publicly available on GitHub:
The repository includes the Electron application, native SmartSpectra integration, measurement-processing logic, guided breathing functionality, tests, screenshots, and setup instructions.
Technology Stack
| Technology | Purpose |
|---|---|
| Electron | Desktop application runtime |
| Node.js | Native SDK integration |
| TypeScript | Type-safe application logic |
| Presage SmartSpectra SDK | Contactless physiological sensing |
| Protocol Buffers | Measurement decoding |
| HTML & CSS | User interface and animations |
| Canvas API | Camera preview and live charts |
| esbuild | Application bundling |
Running PulseFlow Locally
Clone the repository:
git clone https://github.com/Ezequie1Sc/PulseFlow.git
cd PulseFlow
Install dependencies:
npm ci
Create a local environment file.
On Windows PowerShell:
Copy-Item .env.example .env
Configure your Presage SmartSpectra API key in .env:
SMARTSPECTRA_API_KEY=your_presage_api_key
Start the desktop application:
npm run dev
A compatible webcam, camera permissions, and a valid API key are required.
The repository's README contains additional information about installation, application architecture, privacy, and troubleshooting.
How It Responds to Human Signals
The Presage SmartSpectra SDK is the foundation of PulseFlow.
The application uses live camera-based physiological estimates rather than simulated datasets.
1. Camera-Based Signal Acquisition
After the user explicitly consents to monitoring, PulseFlow initializes the SmartSpectra Node.js SDK and connects to a selected webcam.
The application requests these metrics:
requestedMetrics: [
MetricType.PULSE_RATE,
MetricType.BREATHING_RATE,
]
SmartSpectra processes the camera input and generates physiological estimates along with signal-validation information.
2. Processing SDK Events
PulseFlow listens for several SmartSpectra events:
| Event | Purpose |
|---|---|
processingStatus |
Reports SDK processing states |
validationStatus |
Provides signal-quality feedback |
metrics |
Delivers physiological measurements |
videoOutput |
Supplies camera preview frames |
error |
Reports SDK errors |
Incoming measurement messages are decoded using Protocol Buffers.
The application processes the measurements before forwarding accepted values to the user interface.
3. Validating Physiological Measurements
One of my priorities was avoiding misleading readings.
PulseFlow checks incoming measurements using its validation and filtering logic.
If SmartSpectra cannot provide a suitable signal, the interface communicates that state rather than presenting fabricated numbers.
This makes the experience responsive not only to the physiological readings themselves, but also to whether valid measurements are available.
4. Updating the Interface in Real Time
When an accepted measurement arrives:
- The current physiological value updates.
- The corresponding historical chart receives a new reading.
- An active breathing session collects the accepted sample.
- Collected samples contribute to the final session summary.
The guided breathing animation operates independently of the measurement pipeline.
This separation is intentional: an animated breathing guide should never be mistaken for an actual measured respiration signal.
5. Challenges During Development
Integrating a native physiological sensing SDK introduced challenges beyond typical frontend development.
I encountered issues involving camera capture conditions, frame rate, signal validation, and measurement availability.
During debugging, SmartSpectra returned feedback including:
Place more of the chest in view.Use a camera mode that provides at least 25 frames per second.
These messages taught me that successfully displaying a camera preview does not necessarily mean physiological sensing can produce usable measurements.
I adjusted the camera framing and capture conditions and eventually obtained valid live readings.
Another important challenge was integrating native capture operations into Electron while keeping the application's main process, renderer, and measurement-processing responsibilities separated.
This project reinforced the importance of testing with actual hardware rather than relying exclusively on successful builds or automated tests.
Prize Categories
I'm entering PulseFlow in both special prize categories.
Most Creative or Delightful Use
What inspired PulseFlow was the idea of transforming physiological sensing into a simple, interactive desktop experience.
Instead of displaying measurements on a conventional monitoring dashboard, I combined real-time sensing with guided breathing, restrained motion, live charts, and session summaries.
The experience is deliberately minimal.
I wanted to demonstrate that advanced sensing technology does not need a complicated interface to be engaging.
The combination of real physiological measurements and a calm, interactive design is what makes PulseFlow distinctive.
Best Thoughtful Real-World Use
PulseFlow explores a practical use of contactless sensing: allowing people to observe physiological estimates while participating in a voluntary breathing exercise.
It is designed for users curious about general wellness and physiological sensing who may not own a wearable device.
The experience emphasizes:
- Using an ordinary webcam.
- Requiring explicit camera consent.
- Providing clear measurement feedback.
- Allowing users to stop monitoring.
- Explaining when readings are unavailable.
- Presenting understandable charts and session summaries.
- Avoiding unnecessary persistent physiological histories.
PulseFlow is intended for educational and general wellness exploration.
It is not intended to diagnose medical conditions, recommend treatments, or support clinical decision-making.
Consent and Data Handling
Privacy and user control were important considerations during development.
Because PulseFlow uses camera-based physiological sensing, I wanted the application to make its purpose clear and require intentional participation.
Camera Consent
PulseFlow requires explicit user consent before beginning camera-based monitoring.
The application presents information about camera access and allows users to control when monitoring starts and stops.
Camera and Physiological Data
PulseFlow uses a webcam through SmartSpectra to obtain physiological estimates.
Camera frames can be displayed as a preview in the desktop application.
Accepted measurements are used to update live indicators, historical charts, and temporary session summaries.
Storage and Retention
PulseFlow does not implement a dedicated persistent database for physiological measurements, user profiles, or session histories.
The application is designed around temporary measurement data used during active monitoring and guided breathing sessions.
This describes the application's own architecture, not the independent storage or retention behavior of Presage's SDK or services.
Data Sharing and SDK Telemetry
PulseFlow configures SmartSpectra with:
enableTelemetry: false
This disables the configurable telemetry option used by the application.
However, this setting should not be interpreted as proof that the SDK performs no network communication.
SDK authentication, operational communication, and any provider-side processing are governed by Presage's implementation and documentation.
PulseFlow does not implement an additional application backend for uploading physiological session histories.
Optional AI Services
PulseFlow does not require a separate generative AI service for physiological measurement processing or guided breathing.
Physiological estimates originate from the Presage SmartSpectra SDK.
Deletion and User Control
Users can stop monitoring and manage or reset the active session through the application's controls.
PulseFlow does not offer a permanent cloud-based physiological history or user account system.
Temporary session data is intended for the active application experience.
Responsible Use
PulseFlow is an experimental application for general wellness exploration and technical demonstration.
It is not a medical device and must not be used for:
- Medical diagnosis or treatment.
- Clinical decision-making.
- Emergency monitoring.
- Covert surveillance.
- Non-consensual physiological monitoring.
Session Results
One of the features I enjoyed building was the measurement-based session summary.
Instead of ending the breathing exercise without feedback, PulseFlow presents an overview of the measurements accepted during the session.
In one completed 60-second demonstration, the application reported:
| Measurement | Result |
|---|---|
| Session duration | 60.0 seconds |
| Average heart rate | 84.9 BPM |
| Average breathing rate | 8.0 breaths/min |
| Valid pulse samples | 69 |
| Valid breathing samples | 15 |
| Session status | Completed |
These results are observations from a particular demonstration session, not evidence of therapeutic or medical benefits.
What I Learned
Building PulseFlow taught me several lessons about developing software that interacts with real hardware and physiological signals.
Native SDK integration is more than connecting an API.
Camera processing, SDK events, measurement decoding, signal validation, and visual presentation all need to work together.
Hardware conditions directly affect the experience.
Lighting, movement, camera positioning, and frame rate influence whether contactless sensing can produce usable measurements.
Missing data should remain missing.
An honest interface communicates when a measurement is unavailable rather than fabricating values to make the dashboard appear functional.
Thoughtful design can make complex technology approachable.
Clear typography, restrained animations, and descriptive feedback help users understand an unfamiliar sensing experience.
Final Thoughts
PulseFlow began with a simple question: what could I build using an ordinary webcam and real-time human signals?
It became an opportunity to explore native desktop development, physiological sensing, data validation, real-time visualization, and responsible interaction design.
There is still room for improvement, particularly in camera compatibility, accessibility, and additional privacy controls.
However, successfully receiving and displaying live SmartSpectra measurements was an important milestone for this project.
Thank you to Presage and DEV Community for organizing the challenge and encouraging developers to explore new forms of human-computer interaction.
PulseFlow — Your body, in real time.
GitHub: https://github.com/Ezequie1Sc/PulseFlow
Video Demonstration: https://youtu.be/8ztd4aoxduk
SmartSpectra SDK: https://smartspectra.presagetech.com/docs/nodejs/




Top comments (0)