CarePilot: Intelligent Care Navigation System

• 

  Client web interface

About the Project

Inspiration I work for a company whose aim is to revolutionize dialysis treatment using unique diagnostic tools, signal processing, data analytics and AI. Through this work, I've witnessed firsthand how fragmented healthcare systems and information overload can delay critical decisions and compromise patient outcomes. Clinicians spend hours on documentation instead of patient care, while patients struggle to navigate complex treatment plans. I envisioned CarePilot as a solution that could bridge these gaps—using AI not to replace human judgment, but to amplify it, giving both providers and patients the clarity and support they need at every step of the care journey.

What it does CarePilot is an AI-powered clinical decision support and patient management platform designed to streamline the care journey from diagnosis to follow-up. The system integrates predictive analytics, natural language understanding, and multimodal data fusion (EHR text, lab results, imaging metadata, wearable data) to provide clinicians and patients with actionable insights. Key capabilities include smart triage and routing that uses patient symptoms, vitals, and history to prioritize cases and suggest appropriate next steps or referrals; personalized care plans that dynamically generate care pathways using evidence-based guidelines and patient-specific data; AI-assisted documentation that transcribes and summarizes clinician-patient conversations in real time; predictive health monitoring that continuously evaluates risk for adverse events and alerts care teams early; and a patient engagement layer with a conversational companion app that helps patients adhere to treatment plans and provides education in plain language.

For this hackathon, I built CarePilot Lite—a focused proof-of-concept demonstrating automated patient risk assessment and care plan generation for diabetes and hypertension management. The system analyzes clinical data including blood glucose, HbA1c, and blood pressure readings, then generates evidence-based, categorized care recommendations with urgency indicators to help clinicians prioritize interventions.

How I built it CarePilot Lite is built as a modern full-stack TypeScript application using a monorepo architecture with three packages: a React 18 frontend with Vite for a fast, responsive user interface; a Node.js backend with Express.js handling API endpoints, risk assessment logic, and optional OpenAI integration for natural language summaries; and a shared layer with centralized TypeScript types and Zod validation schemas ensuring type safety across the stack. The clinical logic implements evidence-based risk stratification algorithms for diabetes and hypertension, with optional LLM enhancement to generate human-readable care plan summaries. I prioritized modularity and testability throughout, creating a clean separation of concerns between validation logic, risk assessment, care plan generation, and presentation layers.

Challenges I ran into Balancing clinical accuracy with POC simplicity was one of the biggest challenges—I had to carefully select which risk factors and thresholds to include while ensuring the recommendations remained clinically valid and evidence-based. Healthcare data comes in many formats, so building robust validation that handles various input formats while providing clear error messages required careful schema design with Zod. Setting up npm workspaces with proper TypeScript compilation, shared types, and build orchestration across three packages took significant debugging to get the configuration right. I also grappled with deciding when to use rule-based logic versus LLM-generated content, ultimately opting for deterministic risk assessment with optional LLM enhancement for summaries to ensure reliability while adding flexibility. Finally, to keep dependencies minimal for the POC, I built custom test utilities rather than using a full framework, which required careful design to ensure comprehensive coverage.

Accomplishments that I'm proud of I'm proud of building a complete, working system from data input through risk assessment to actionable care plans in a short timeframe. The implementation uses evidence-based risk stratification that produces clinically meaningful recommendations, not just generic advice. I achieved full type safety across the entire stack with shared TypeScript types and runtime validation, created a modular and testable codebase with clear separation of concerns that could scale to a production system, and wrote over 20 test cases covering validation, risk assessment logic, and API endpoints. The user experience includes an intuitive interface with example data, clear error messages, and organized care plan presentation. Most importantly, I built the system with extensibility in mind, including hooks for future enhancements like database integration, authentication, and additional clinical conditions.

What I learned This project reinforced that healthcare data is inherently messy—real-world clinical data requires flexible parsing and validation, making robust input handling critical for any healthcare application. I learned that AI augmentation is more effective than AI replacement; the best approach combines deterministic, evidence-based logic for critical decisions with AI enhancement for communication and summarization. Working with a monorepo showed me how sharing types and validation logic across frontend and backend eliminates entire classes of bugs and improves development velocity. I also learned that POC scoping is an art—knowing what to include versus defer was crucial, so I focused on core functionality while documenting future enhancements. Comprehensive testing allowed me to refactor and iterate quickly without fear of breaking existing functionality. Perhaps most importantly, I learned that clinical domain knowledge matters deeply; understanding the medical context behind risk thresholds and care recommendations was essential for building something genuinely useful, not just technically impressive.

What's next for CarePilot: Intelligent Care Navigation System The immediate next steps for CarePilot Lite include expanding condition coverage to cardiovascular disease, chronic kidney disease, and COPD; adding medication interaction checking using drug databases; implementing persistent storage with PostgreSQL; building user authentication and role-based access control; and adding audit logging for clinical decision tracking. Medium-term goals for a full CarePilot system include EHR integration with HL7 FHIR API connectors for Epic, Cerner, and other major systems; multimodal data fusion incorporating lab trends, imaging reports, and wearable device data; predictive analytics using machine learning models for readmission risk and adverse event prediction; clinical NLP to extract structured data from unstructured notes; and a patient portal mobile app for viewing care plans and tracking medications.

The long-term vision for CarePilot Enterprise encompasses population health management with aggregate analytics across patient cohorts for quality improvement; real-time monitoring integration with hospital systems for continuous risk assessment; AI-powered clinical trial matching based on eligibility criteria; full HIPAA compliance framework with encryption, audit trails, and access controls; standards-based interoperability with health information exchanges; and pursuing FDA clearance as a clinical decision support tool. The ultimate goal is to create a comprehensive care navigation platform that reduces clinician burnout, improves patient outcomes, and makes high-quality healthcare more accessible and efficient.

Built With

• client-server-architecture
• css
• custom
• developer-experience
• evidence-based-clinical-algorithms
• express.js
• git
• github
• html
• html/css-frameworks-&-libraries:-react-18
• javascript
• json
• monorepo-architecture
• node.js-18+
• npm-workspaces
• npm-workspaces-(monorepo)-apis:-openai-api-(optional)
• openai-api
• react-18
• restful-api
• runtime-schema-validation
• test
• typescript
• typescript-compiler
• vite
• zod
• zod-runtime-&-tools:-node.js-18+