MedSafe

Inspiration

Medication labels can be difficult to interpret, especially when people take multiple medications at once. We wanted to build something that could make medication information easier to understand while helping users identify potential issues worth discussing with a healthcare professional.

Our idea became MedSafe, a privacy-focused medication safety assistant that combines medication lookup, active-ingredient tracking, and safety checks in one simple mobile application.

What it does

MedSafe allows users to build a personal medication list and look up medications using RxNorm. When a medication is selected, MedSafe retrieves its active ingredients and stores them locally.

The app can then:

• Search for medications using RxNorm
• Automatically retrieve active ingredients
• Track medications and their dosages/frequencies
• Detect duplicate active ingredients across medications
• Check medications against an included interaction database
• Provide a centralized safety dashboard
• Scan medication labels and prepare them for OCR-based identification
• Keep medication data stored locally on the device

MedSafe is designed to identify potential issues to discuss with a healthcare professional, rather than claiming that a medication combination is safe or replacing a doctor or pharmacist.

How we built it

MedSafe was built as a React Native + TypeScript mobile application using Expo.

Our main technologies include:

• React Native / TypeScript — mobile application
• Expo / Expo Router — development and navigation
• SQLite — local medication storage
• RxNorm — medication and active-ingredient identification
• Node.js / Express — OCR backend
• Google Cloud Vision — medication-label OCR
• SQL — medication, ingredient, and interaction relationships

We designed the application around a local-first architecture:

Mobile App
    ↓
Local SQLite Database
    ↓
Safety Engine
    ↓
Potential Issues

This allows the core medication data and safety checks to operate locally rather than requiring users to send their entire medication history to a remote service.

Challenges we ran into

One of our biggest challenges was designing the database relationships between medications and their active ingredients. A single medication can contain multiple ingredients, while the same ingredient can appear in multiple medications.

We solved this using separate medications, ingredients, and medication_ingredients tables.

We also had to account for database migrations as the application evolved. For example, after adding RxCUI support, existing databases on devices needed to gain the new column without deleting the user's existing medications.

Another challenge was integrating external medication data. RxNorm provides standardized medication and ingredient information, but it isn't itself a complete drug-interaction database, so we had to keep medication normalization separate from our safety-checking logic.

Finally, getting the scanner architecture working required separating the mobile camera from the OCR backend while keeping API credentials out of the mobile application.

Accomplishments that we're proud of

We're proud that we built a functional end-to-end medication management system rather than just a static prototype.

MedSafe can take a medication from user input → RxNorm identification → active ingredients → local database → safety analysis.

We're especially proud of our duplicate-ingredient detection. For example, if two different medications contain acetaminophen, MedSafe can recognize that they share an active ingredient even though the medication names are different.

We also built the application so that medications can be added, edited, deleted, and rechecked through the safety dashboard.

Most importantly, we designed MedSafe with the principle that medication safety information should support conversations with healthcare professionals, not replace them.

What we learned

We learned how much complexity is involved in building an application that combines mobile development, databases, external APIs, and safety-related information.

We gained experience with:

• React Native and Expo
• TypeScript
• SQLite database design
• Database migrations
• API integration
• RxNorm medication normalization
• OCR pipelines
• Local-first application architecture
• Designing software around safety and uncertainty

We also learned that building a healthcare-related application requires being careful about what the software claims. A technically correct database lookup isn't the same thing as a personalized medical recommendation.

What's next for MedSafe

Our next goal is to make the scanning workflow fully automatic:

Scan label → OCR → identify medication → RxNorm lookup → confirm → save → safety check

We also want to expand the medication data used for safety checks, improve OCR accuracy, add clearer explanations of potential interactions, and make the interface easier to use.

Longer term, we envision features such as medication schedules, medication history, caregiver/pharmacist reports, and an AI-powered explanation layer that translates technical medication information into plain language while keeping the underlying safety checks deterministic and transparent.

Built With

• react
• sqlite
• typescript