Inspiration

Our team was deeply moved by the chaotic scenes often witnessed in India's large, multi-specialty hospitals. We saw countless patients, many in visible distress, wandering from one department to another, confused about which doctor to consult for their symptoms. The sight of elderly patients standing in seemingly endless queues just to get an appointment token was heartbreaking. We realized that this inefficient manual triage process not only increased patient anxiety but also put immense pressure on hospital staff. We wanted to use our engineering skills to bring solution to this chaos and create a smoother, more human-centric experience. We dreamed of a solution where technology doesn't replace the human touch but empowers patients and optimizes hospital resources. That's how C.A.R.E. was born.

What it does

C.A.R.E. is an integrated web-based platform designed for both patient mobile devices and hospital-placed kiosks. It streamlines the entire pre-consultation journey, from symptom analysis to appointment confirmation.

Emergency First Aid Triage: The very first screen acts as a safety valve, with a bold disclaimer directing patients to immediate in-person help for emergency cases.
Intelligent Symptom-to-Department Routing: Patients input their symptoms through a user-friendly interface. Our system then uses a rule-based algorithm (designed as a foundation for future machine learning) to suggest the most appropriate medical departments, even providing a percentage-based match for clarity. Crucially, it lists all departments to allow for user agency.
Dynamic Queue & Token Management: Instead of physical tokens, the system generates a digital token with a clear Token Number (e.g., GS-104 for General Surgery). This token is linked to a live, real-time queue tracker on the patient's phone, allowing them to relax or wait comfortably elsewhere instead of in a crowded waiting hall.
Integrated UPI Payments: To further reduce queues, patients can make the OPD fee payment directly within the app via a simulated UPI QR code, receiving instant confirmation.
Doctor's Side Control: Doctors have their own secure dashboard to manage their schedules, call the next patient, or mark a patient as a "wrong department" case.
Reinforcement Learning Loop for Self-Correction: When a doctor rejects a patient, the system prompts the patient (after booking a new, correct appointment) to input their actual diagnosis. This data is fed back into the symptom-routing logic, allowing the algorithm to learn from its past misclassifications and become more accurate over time.

How we built it

We aimed for a robust yet rapidly prototype-able tech stack:

Frontend: We used a combination of HTML, CSS (specifically Tailwind CSS for clean, responsive design), and React to build a modern single-page application that feels smooth on both mobile and kiosk screens.
Backend & Database: For our initial prototype, we used LocalStorage and in-memory arrays within our React application to manage and persist data like department lists, doctor schedules, and patient appointment state, simulating a full backend. We focused on making the UI and logic work seamlessly.
Real-Time Simulation: We simulated the real-time queue updates with basic JavaScript functions and state management, providing a proof-of-concept for how a proper WebSocket or Server-Sent Events (SSE) system would function.
AI/Triage Logic: We implemented the initial triage system using a defined matrix and nested conditional logic within our JavaScript code. This creates a solid foundation that can easily be swapped out for a call to a machine learning model via an API later.
Simulations: Payment was simulated with a dummy QR code and payment success state. SMS notifications were simulated with internal app-level notifications, showcasing the user flow without the complexity of actual service integrations.

Challenges we ran into

We did hit some walls!

Complex Multi-Role User Flow: Designing the branching logic for new patients vs. follow-up cases and then integrating that with the doctor’s control flow was far more complex than we anticipated. Mapping out every potential 'what if' scenario in the UI state management felt like trying to solve a 3D puzzle.
Designing for Dual Modes (Kiosk vs. Mobile): Creating a user interface that looks great and works intuitively as both a large-screen kiosk app (with big touch targets) and a compact mobile web app required careful planning and constant testing.
Simulating Real-Time Without a Real Backend: Making the doctor-side state (e.g., calling the next token) immediately update on the patient-side was a huge challenge without an active server or a real-time database. We spent a lot of time engineering JavaScript workarounds to create a convincing simulation for the demo.
Defining the AI Routing Matrix: Even a simple rule-based system requires a clear logic. We had to do some basic medical domain research to create realistic matching percentages (e.g., which conditions could be treated by General Surgery vs. Gastroenterology).

Accomplishments that we're proud of

A Fully Functional End-to-End Demo: We are incredibly proud that we succeeded in building a prototype where you can go from symptom input to a confirmed, payed, and geotagged token. The demo flow actually works!
Learning Multi-Role Web Architecture: This was our first time building an application with distinct user types and interconnected data states. Successfully coordinating the interaction between the patient and the doctor views is a huge milestone for us.
Implementing the Reinforcement Learning Proof-of-Concept: While simulated, actually programming the logic for the feedback loop (wrong department $\rightarrow$ correct diagnosis entry $\rightarrow$ algorithm update) was an incredible learning experience and a feature we are really proud of pitching.
Creating a Real-World Problem Solution: It's an incredible feeling to take a real, visible problem we've all seen and create a working technology that can legitimately solve it.

What we learned

We learned so much more than just coding!

The Power of State Management in React: Handling complex forms and multi-step processes taught us the critical importance of a clean, structured approach to application state.
Real-Time Communication Basics: Even though simulated, trying to create synchronous state updates between different "user views" without a proper server forced us to think deeply about how real-time communication on the web works.
The Importance of User-Centric Design: In a health-tech app, making the interface dead-simple and stress-free is not a "nice-to-have"; it's an essential requirement. We learned to prioritize clear actions and helpful guidance at every step.
The Power of Prototyping and Simulation: We learned that you don't need a perfectly completed final product with fully-live APIs to have a successful hackathon entry. We learned how to prioritize and simulate non-core functions (like payment and SMS) to tell a complete user story.

What's next for C.A.R.E. (Clinical Automated Routing & Evaluation)

This hackathon is just the beginning! Our immediate future goals are:

Integrating a Real Full-Stack Backend: Migrating from LocalStorage to a real database (like PostgreSQL with Node.js/Express) and using technologies like WebSockets (e.g., socket.io) or Supabase Realtime for genuine, instant queue updates.
Replacing Rule-Based Triage with an Actual AI Model: We plan to train and integrate a dedicated Natural Language Processing (NLP) model to process user symptoms, making the symptom-to-department routing significantly more robust and accurate. This is where we'll implement the actual Reinforcement Learning loop for real.
Secure Payment & Notification Integration: Integrating a proper payment gateway (like Stripe, Razorpay) and a real SMS API (like Twilio) to complete the functional ecosystem.
Piloting in a Hospital: Our ultimate goal is to pilot C.A.R.E. in a real local hospital, collecting actual data, getting patient and doctor feedback, and proving that this technology can truly make healthcare more efficient and humane.