CareWatch

Gemini Overview Page
Patients Page
Home Page
Patient Alerts

Inspiration

Healthcare workers often need to monitor multiple patients at once and quickly identify who may need greater attention. We wanted to explore how technology could help make patient monitoring more organized and easier to understand without replacing clinical judgment.

This inspired us to build CareWatch, a patient monitoring and triage assistant that brings patient vitals, alerts, priorities, and trends into one dashboard.

What it does

CareWatch provides a centralized dashboard where healthcare workers can monitor patients' vital signs, including:

Heart rate
SpO₂
Temperature
Patient status and priority

The system uses predefined Java rules to identify abnormal vital signs and assign patients a priority level such as Stable, Monitor, or High.

CareWatch also tracks historical vital readings so users can see how a patient's condition has changed over time.

For patients requiring attention, CareWatch uses the Gemini API to generate a concise explanation of why the patient received their current priority.

Importantly, Java determines the priority and alert reasons, while Gemini explains them. The AI is not used to diagnose patients or recommend treatment.

How we built it

We built CareWatch using a full-stack architecture:

Frontend: React + Vite
Backend: Java + Spring Boot
API: REST
AI: Google Gemini API
Build Tool: Maven
Version Control: Git + GitHub

The backend is organized into controllers, services, repositories, and models.

Patient data and vital readings are processed by the Java backend, where predefined rules determine alert status and priority. The resulting structured information can then be sent to Gemini to generate a natural-language explanation.

The frontend communicates with the backend through REST APIs to display patient information and explanations.

Challenges we ran into

One of our biggest challenges was figuring out how to incorporate AI without giving the AI responsibility for medical decision-making.

We decided that the priority system should remain rule-based and deterministic, while Gemini would only explain information that had already been determined by the backend.

We also had to work through integrating the Gemini API with a Java Spring Boot application, managing API keys securely, designing the request/response structure, and testing our REST endpoint.

Another challenge was coordinating the backend and frontend development across the team while keeping our API structure consistent.

Accomplishments that we're proud of

We are proud of building a working end-to-end prototype that combines traditional backend logic with generative AI.

Some of our key accomplishments include:

Building a Spring Boot backend for patient monitoring
Implementing rule-based patient priority and alerts
Supporting patient vital history and trends
Creating REST APIs for the frontend
Successfully integrating the Gemini API with Java
Generating patient-specific explanations from structured data
Building the foundation for a React monitoring dashboard
Working collaboratively using Git and GitHub

Most importantly, we created a clear separation between automated rule-based decisions and AI-generated explanations, which was an important design principle for our project.

What we learned

We learned how to design and connect different parts of a full-stack application rather than treating the frontend, backend, and AI integration as separate pieces.

We gained experience with:

Building REST APIs with Spring Boot
Structuring a Java backend using controllers, services, repositories, and models
Integrating a third-party AI API
Working with API keys and environment variables
Using Git branches and pull requests for team development
Designing AI features with clear boundaries and responsibilities

We also learned that using AI effectively isn't necessarily about letting the AI make every decision. In our case, combining deterministic rules with AI-generated explanations gave us a more controlled approach.

What's next for CareWatch

We would like to continue developing CareWatch by:

Connecting the React dashboard to the backend APIs
Adding interactive patient trend visualizations
Improving the patient monitoring interface
Adding real-time vital data
Connecting the application to a persistent database
Expanding automated testing
Improving the Gemini explanation experience
Adding authentication and role-based access

Our long-term goal is to continue exploring how AI can support healthcare workers by making complex patient information easier to understand while keeping important decisions transparent and controlled.