Rxguard

Inspiration

Every year, millions of patients face preventable medical emergencies because traditional clinical workflows rely on static medical charts. These workflows fail to catch dangerous drug-to-profile interactions when a patient's vital signs are constantly shifting. RxGuard was built to turn passive health tracking into an active, predictive system—processing multi-axis biometric streams to automate real-time patient triage and safety.

What it does

RxGuard is a clinical decision support platform that automatically flags drug conflicts based on live physiological metrics. The platform continuously parses a 13-axis biological payload to compute interaction risks in milliseconds. This includes metabolic and renal vitals like estimated GFR and blood glucose levels, live wearable telemetry such as heart rate, heart rate variability, and continuous SpO2, as well as core clinical inputs like patient age, BMI, and active drug regimens. If a clinician prescribes a medication that clashes with this live biochemical state, the dashboard instantly flags the critical hazard with a percentage-based conflict index.

How we built it

We engineered a decoupled dual-cloud architecture designed for high-throughput machine learning inference and strict data isolation:

• The Predictor Engine runs an optimized XGBoost gradient boosting classifier built in Python, trained to map non-linear correlations across continuous biometric features.
• The High-Performance Backend was developed using FastAPI and scaled on Render via a multi-worker Gunicorn and Uvicorn pipeline to serve low-latency prediction endpoints.
• The Secure Frontend consists of an interactive user dashboard deployed on Vercel, communicating via a custom serverless Node.js reverse proxy to securely mask backend cloud APIs.
• The Hardware Emulator bypasses physical device requirements through the integrated Symbiote Demo Watch framework built directly into the UI, emulating a continuous hardware stream to simulate real-time patient shifts with zero physical dependencies.

Challenges we ran into

• Asynchronous Cold-Start Latency & Telemetry Synchronicity: In an asynchronous inference lifecycle using decoupled cloud microservices, handling incoming real-time 13-axis bio-telemetry payloads introduced significant serialization overhead. The initial system state faced synchronization bottlenecks where web-client state updates lagged behind the Python inference loop, threatening real-time triage consistency. We solved this by implementing an event-driven JSON serialization pipeline that optimizes data payloads prior to hitting the API gateway.

• **CORS Pre-flight Restrictions & Secure Token Abstraction:Because modern browser sandboxing restricts direct cross-origin HTTP calls within production environments, routing raw telemetry packets directly to an external backend exposed sensitive API endpoints in browser inspectors. Bypassing this required engineering a secure, serverless Node.js reverse proxy on Vercel to handle token abstraction and route requests safely via a server-to-server connection, shielding the machine learning deployment architecture from unauthorized exposure.

Accomplishments that we're proud of

We successfully engineered a functional, end-to-end full-stack pipeline bridging an asynchronous Python inference engine with a low-overhead frontend. We achieved zero-exposure API security using reverse proxies to completely mask server tokens from browser inspectors. Finally, we created a flawless hardware simulation system that makes the platform immediately testable and presentable to reviewers anywhere.

What we learned

We mastered the art of managing decoupled production lifecycles, optimizing asynchronous cloud routing, tuning hyper-parameters for clinical biometric datasets, and deploying production-grade WSGI/ASGI network wrappers.

What's next for RxGuard

Our immediate production roadmap focuses on scaling RxGuard from an isolated decision support engine into an enterprise-grade hospital network deployment. 1.Distributed Clinical Telemetry Infrastructure:*We plan to integrate RxGuard directly with real-world Electronic Health Record (EHR) systems using Fast Healthcare Interoperability Resources (FHIR) APIs. This will establish secure, persistent data pipelines allowing hospitals to stream live ICU and ward telemetry straight into the platform. 2.Real-Time Adverse Drug Reaction (ADR) Triage Dashboard: We will build a high-throughput, centralized monitoring command center for hospital staff. This dashboard will automatically aggregate cross-patient telemetry to map the real-world physiological response of specific drug combinations across diverse patient cohorts, immediately alerting clinical teams when an aggregated ADR risk index spikes across a specific ward or demographic.

how we built it

Built With

• css3
• fastapi
• gunicorn
• html5
• javascript
• json
• node.js
• numpy
• pandas
• pydantic
• python
• render
• rest-apis
• scikit-learn
• serverless-functions
• uvicorn
• vercel
• xgboost