• 

• 

CareCompass

Inspiration

I've watched international students around me panic at 11 PM. Chest tight, not sure if they need the ER or if a $50 urgent care visit would cover it. The problem isn't that they don't care. It's that the U.S. healthcare system was never built for them.

Over 1.1 million international students are in the U.S. right now, a record high. When they get sick, they hit the same wall every time: What does my insurance cover? Is this serious enough for the ER? What do I say to the doctor? And they start from scratch the next visit, because nothing remembers them.

The average ER visit runs $2,200 out of pocket. A lot of those visits could have been $50 urgent care copays if the student had just known. That's not a medical gap. It's a navigation gap. That's what I built CareCompass for.

What it does

CareCompass helps international students figure out what to do when they get sick in the U.S. Not diagnose them. Navigate them.

You set it up once: upload your insurance card, past doctor notes, and lab reports. CareCompass reads everything, pulls out what's clinically relevant, and stores it.

The next time you feel sick, you describe your symptoms in your own language, and you get four things back:

• Where to go (urgent care, ER, primary care or take self care) and why
• What it will likely cost based on your actual insurance plan
• Which nearby providers take your plan
• A short note you can read at the front desk, in your native language via ElevenLabs, so you can hear it before you walk in

What makes this different from a symptom checker is that it remembers you. Instead of starting over every visit, it looks back: "You had similar symptoms two weeks ago. Your last lab showed low hemoglobin. Worth mentioning." That's built from your records, not pulled from a search.

How we built it

Frontend is Next.js 14 with TypeScript and Tailwind CSS. The UI has two modes: a setup flow you run once, and a symptom flow you return to whenever you need it. A persistent sidebar shows your full visit history.

Backend is Node.js API routes handling document ingestion, symptom analysis, and session storage.

For AI reasoning we used OpenAI GPT-4 with prompts that pull from three sources at once: your parsed insurance data, your extracted medical history, and your current symptoms. The prompt design keeps the system in navigation mode throughout.

OCR handles the document parsing. Insurance cards break down into structured fields (copays, deductibles, network tiers). Medical documents get read for lab values and prior conditions. All of it goes into persistent context.

ElevenLabs does the voice work. The doctor-ready note gets read aloud in the user's preferred language. This is not cosmetic. It's for students whose medical vocabulary is stronger in Hindi or Mandarin than in English.

MongoDB holds everything across six collections: user profiles, insurance data, medical contexts, symptom sessions, provider recommendations, and visit history. The persistent identity is the whole product. Without the database, there is no "CareCompass knows you."

Challenges we ran into

Getting the clinical insights to actually reference prior history was the hardest part. The key demo moment is when CareCompass connects today's symptoms to something in a past visit. Getting GPT-4 to reason across multiple documents and sessions without hallucinating or going vague took a lot of prompt iteration.

Insurance card OCR was messier than expected. Real cards have wildly inconsistent layouts. Building a parser that reliably pulled copays, deductibles, and network info across formats meant handling a lot of edge cases.

Keeping the system in navigation mode required constant attention. Every design decision had one test: does this feel like help deciding what to do, or does it feel like a diagnosis? That line matters ethically and for user trust. Getting the AI to stay practical without reading like a liability disclaimer took real work.

ElevenLabs latency added friction in the demo flow. Audio generation is not instant. Making that feel intentional rather than broken meant paying close attention to loading states and timing.

Accomplishments that we're proud of

The clinical insights actually work. When Ananya describes chest tightness and shortness of breath, CareCompass surfaces: "Similar symptoms were reported two weeks ago. Your hemoglobin levels from your last lab may be contributing to fatigue." That's running end to end, not mocked, not hardcoded.

The ElevenLabs moment holds up. Playing the doctor-ready note in Hindi, letting silence sit for a beat, then playing it in English communicates the point of the product more clearly than any explanation could.

MongoDB is doing real work here. The persistent identity, the fact that CareCompass knows Ananya across multiple visits and reasons over her full history, only exists because of the database architecture. Six collections, not a couple of records with "MongoDB" in the tech stack.

The two-mode design (setup once, use repeatedly) reflects product thinking that most hackathon health apps skip.

What we learned

Most ideas add text-to-speech so a button announces itself. Using it so someone can hear their own medical situation explained in their native language before walking into a clinic is a completely different thing. It changed how we thought about the rest of the product. Voice is not a feature, it's the moment the product becomes real for someone.

We also learned that being specific about who you're building for forces better decisions. "International students" is easy to say. A USF grad student with asthma and low hemoglobin who can't tell if chest tightness is a $50 problem or a $3,000 one made every design call concrete.

Building around memory from day one meant rethinking the data model, the prompts, and the UI together. The default assumption in most health tools is single session. Getting out of that early was the right call.

What's next for CareCompass

Supermemory integration for long-term context across months of visits. Right now the system reasons across a handful of sessions. With Supermemory, it could notice: "You've reported shortness of breath four times in six months, always in the fall." That's the kind of pattern that actually matters.

A mobile app, because nobody is opening a laptop at 11 PM with chest tightness.

University partnerships with campus health center data and student-specific insurance plans pre-loaded. Every university with a large international student population is a natural distribution channel.

Multilingual expansion to Mandarin, Spanish, Arabic, and Portuguese, which cover the four largest international student groups after Hindi speakers.

EHR integration to replace manual document uploads with verified records.

A pharmacy copay navigator for the same insurance-aware cost guidance on prescriptions.

The goal is a health companion that knows your history well enough to catch patterns you've stopped noticing yourself.

Technologies used:

OpenAI — GPT-4 handles two things: parsing uploaded medical documents into structured facts (conditions, labs, medications), and reasoning over your symptoms alongside your insurance and visit history to return a care recommendation, clinical insights, and ready-to-use voice scripts. Whisper handles audio transcription so you can speak your symptoms instead of typing them.

MongoDB — Stores everything that makes CareCompass remember you across visits: your insurance profile, extracted medical contexts, and full symptom sessions including the recommendation and clinical insights from each visit. The navigation prompt pulls your most recent sessions as context, which is what enables the "you had similar symptoms two weeks ago" insight.

ElevenLabs — Converts the generated voice scripts to audio using the eleven_multilingual_v2 model, returning an MP3 in your preferred language (Hindi, Spanish, French, German, or English) so you can hear your own medical situation explained before you walk in.

Built With

• authlib
• axios
• elevenlabs
• fastapi
• google-oauth2
• gpt-4o
• httpx
• javascript
• jwt
• llm
• mongodb
• motor
• openai
• openai-api
• pydantic
• pymongo
• pymupdf
• pytest
• python
• react
• react-router-dom
• tailwind-css
• typescript
• uvicorn
• vite
• whisper-1