What I Built
I've always been curious about how far we can push technology beyond what it was originally designed to do.
We use cameras every day to take pictures, record videos, and make video calls. But what if that same camera could help us understand signals from the human body without needing to wear a device?
That question caught my attention.
When I discovered the Presage SmartSpectra SDK, I wanted to explore what was actually possible. I didn't want to just read about it or run a quick example. I wanted to build something I could interact with, experiment on, and learn from.
That's how Aegis Pulse started.
I built a macOS desktop application using Electron, React, TypeScript, and the SmartSpectra SDK to explore contactless pulse and breathing measurements.
Seeing a heart-rate reading appear on screen was exciting, but what really interested me was everything happening behind that number.
How was the signal developing? Why did some measurements settle faster than others? How much confidence did the SDK have in what it was reporting? And what could I learn by making more of that information visible?
Those questions led me to expand Aegis Pulse into five different views: Live Monitor, Signal Lab, Sessions, Diagnostics, and Settings.
Live Monitor is where I can see pulse, breathing, and how confident the SDK is in those measurements. Signal Lab lets me explore the relative waveforms and watch how confidence changes over time.
I added Sessions because I wanted to look more closely at the measurements collected during a run. Diagnostics came from wanting to understand what was happening behind the scenes, especially frame rates, processing delays, and dropped frames.
Settings brings everything together with camera consent, API-key security, privacy information, and accessibility options.
Each view gave me a different perspective on what the application was doing. And the more I explored it, the more questions I wanted to investigate.
Demo
One of the most rewarding moments was seeing real pulse and breathing measurements appear through an ordinary camera.
I recorded a short, silent demonstration using the actual Aegis Pulse application and SmartSpectra SDK.
In the recording, the pulse reaches approximately 92–93 BPM, while the breathing measurements continue to settle. The application shows that difference instead of treating every reading as equally reliable.
The video also demonstrates the camera being released when I stop the session. The application returns to IDLE, and the preview turns off.
The recording begins with a session already running, so it doesn't include the initial consent or Start clicks. Those controls are explained in the application and shown in the project screenshots.
I covered the camera preview with an opaque panel because I wanted to share the software without showing myself on camera.
Here's the demonstration:
Code
Aegis Pulse source code and documentation:
I built the application with Electron, React, TypeScript, and the Presage SmartSpectra SDK.
One area I spent quite a bit of time on was keeping the SDK integration separate from the frontend.
I didn't want API credentials exposed directly to the interface, so the SmartSpectra integration runs through Electron's main process, with a restricted IPC layer connecting it to the React application.
The API key is protected using Electron's macOS-backed encryption facilities.
I also spent time building tests for camera permissions, session behavior, credential handling, and application security.
At the time of preparing this submission, the project passes 188 automated tests, along with TypeScript validation, production build checks, and its configured security scan.
The repository includes the original application source, installation instructions, architecture documentation, security notes, and screenshots from real application sessions.
My original code is available under the MIT License. The Presage SDK has its own licensing terms, and developers who want to run Aegis Pulse need their own Presage API key.
How It Responds to Human Signals
This was probably the part of the project I enjoyed exploring the most.
Once a measurement session begins, the camera sends frames through the application's processing pipeline to the SmartSpectra SDK.
The SDK provides pulse, breathing, confidence, and relative waveform information that Aegis Pulse displays in real time.
I didn't want to build an interface that simply showed numbers and made everything look perfect.
Real measurements take time to settle. Lighting, movement, and camera positioning can affect the readings.
During one recording, I watched the pulse measurement become stable while breathing was still preliminary.
That caught my attention because it showed why confidence matters just as much as the number itself.
Rather than hiding that uncertainty, I wanted the application to make it visible.
That's also why I created Signal Lab. It gives me a way to inspect relative pulse and breathing waveforms while following changes in confidence.
These are relative signals from the SDK, not blood-pressure measurements or independently validated clinical waveforms.
I was also curious about what was happening inside the application while those measurements were coming in.
Was the camera delivering frames consistently? Were frames being dropped? How much delay was being introduced as information moved through the application?
That's where Diagnostics became useful.
During one observed session, Aegis Pulse reported approximately 30 accepted frames per second, with 5,140 out of 5,140 frames accepted and an IPC transit p95 of approximately 3 milliseconds.
Those numbers come from that particular session. They aren't a guarantee of performance across different machines.
The physiological readings haven't been independently validated against a medical reference device either.
For me, being able to explore both the signals and the engineering behind them made the project much more interesting.
Prize Categories
I'm submitting Aegis Pulse in the Best Thoughtful Real-World Use category.
I wanted to explore a technology with real-world potential while creating something that people could understand and control.
The goal wasn't simply to show pulse and breathing measurements. I wanted the user to know when the camera was active, see when readings were still settling, and have a clear way to end the session.
I also wanted developers to have visibility into what was happening behind the interface.
To me, thoughtful technology means more than getting something to work. It means being clear about what the system can do, acknowledging its limitations, and giving people control over how they use it.
Consent and Data Handling
Privacy became one of the most important parts of building Aegis Pulse.
Before a measurement session can begin, the application requires explicit camera consent.
Granting consent alone doesn't turn the camera on. Starting a session is a separate action, and the application provides a Stop & release camera control so users can end measurement whenever they choose.
Camera frames are processed in memory rather than being saved as video files by Aegis Pulse.
But there's something important I discovered while reviewing Presage's documentation.
According to Presage's SDK Privacy Policy, the SDK transmits derived physiological measurements, including pulse, breathing, and HRV, along with session metadata, to Presage for its Insights functionality.
The policy states that camera video and images aren't transmitted to Presage.
Disabling optional SDK telemetry does not disable those measurement transfers.
Initially, I thought disabling telemetry meant less information was leaving the device. Reading the privacy documentation more carefully showed me that these were separate behaviors.
That discovery made me revisit the application's consent and privacy information.
I wanted users to understand what happens to their measurements rather than simply assume the system was completely offline.
I haven't independently inspected the SDK's network traffic, so these disclosures are based on Presage's published policy.
For local storage, Aegis Pulse keeps current-session readings and waveforms in memory rather than writing them into its own diagnostic logs. Those logs contain processing counters and timing information.
The API key is handled through Electron's main process and protected using macOS-backed encryption.
Aegis Pulse is intended for general wellness information and engineering exploration. It isn't a medical device, hasn't been clinically validated, and shouldn't be used for diagnosis or treatment.
What I Learned
When I started this project, I thought getting physiological measurements from a camera would be the biggest challenge.
It turned out to be only one part of the experience.
I spent time working through camera permissions, securing credentials, managing SDK sessions, and making sure navigating between views didn't accidentally create another camera session.
I also learned how important it is to test software beyond an automated test suite.
At one point, I needed to confirm that stopping a session actually released the camera. That meant running the application, examining lifecycle logs, and checking the behavior of the camera stream.
Getting those details right took more investigation than I originally expected.
Another important lesson came from reading the SDK's privacy documentation more carefully.
I had made an assumption about telemetry and data transmission that wasn't completely accurate. Once I understood the difference, I corrected the application's privacy disclosures.
That reminded me that part of engineering is being willing to question your assumptions, inspect the evidence, and change something when you discover a better understanding.
Those lessons were just as valuable as getting the first measurements working.
Credits
Aegis Pulse uses the Presage SmartSpectra SDK.
I referenced Presage's documentation and official examples while developing the integration.
The desktop interface, Electron architecture, camera lifecycle controls, diagnostics, session management, and automated tests were developed as part of this project.
Final Thoughts
Aegis Pulse began with a simple question:
What else can we learn from a camera beyond what we can see in an image?
It turned into a much larger exploration of contactless physiological sensing, software architecture, privacy, and real-time system reliability.
There's still plenty I'd like to investigate, especially around measurement accuracy, different hardware, and how this technology might evolve.
But getting from an idea to a functioning desktop application has been a rewarding experience.
Seeing real measurements appear on screen was exciting. Understanding what was happening behind those numbers made it even more interesting.
And that's one of the things I enjoy most about building software.
Every working system opens the door to another question, another experiment, and another opportunity to learn something new.
