Homepage

Inspiration

Project Story

About the Project

As developers on CoverMyPharma, we were inspired by how frustrating and time-consuming it can be for patients and healthcare providers to deal with insurance paperwork, prescription approvals, and prior authorization processes. Many people face delays not because treatment is unavailable, but because the system around it is slow, repetitive, and hard to navigate. Our goal was to build a tool that could reduce that friction and make pharmacy and insurance-related document handling smarter and faster.

The heart of the project was designing a system that could take uploaded PDF documents, securely process them, extract meaningful text, and return structured insights that could help users understand what actions are needed next. The idea was to make messy healthcare documents easier to interpret and more useful in real time.

How I Built It

The project was built around a modern web stack. On the frontend side, the app uses React with Vite, along with Auth0 for authentication and Gemini-related integrations already configured in the environment and dependencies. The repository includes React, Vite, Auth0, and Google Generative AI support, which shaped how the backend had to integrate with the rest of the system.

The planned web-app flow was:

accept a PDF upload,
Validate the authenticated user token,
Extract text from the PDF,
Send the extracted content to Gemini for analysis.
Return structured results such as medication details, insurance information, required prior authorization status, and recommended next steps. :contentReference[oaicite:2]{index=2}

This structure allowed the backend to act as the intelligence layer of the application. Instead of only storing or forwarding files, it actively transformed unstructured healthcare documents into usable information.

What We Learned

This project taught me a lot about building backend systems for real-world problems, especially in healthcare-related workflows where accuracy, structure, and security matter. I learned how important it is to think beyond just APIs and databases. A backend in this kind of application has to handle authentication, file processing, AI integration, and clean response formatting all at once.

I also gained a better understanding of how authentication services like Auth0 connect with protected API routes, and how environment configuration plays a major role when working across frontend and backend systems. Since the project already had frontend-side Auth0 and Gemini configuration in place, I had to think carefully about how the backend would securely use server-side equivalents of those values. :contentReference[oaicite:3]{index=3}

Another important lesson was about designing for structure. Healthcare documents are often long, inconsistent, and difficult to parse manually. Building a backend that could extract raw text and then turn it into a consistent JSON response made me appreciate the value of clean interfaces between AI systems and application logic.

Challenges We Faced

One of the biggest challenges was bridging the frontend and backend cleanly. The frontend stack was already defined with React, Vite, and Auth0, but the backend was not yet fully wired in, so we had to think through how to create a backend that matched the frontend architecture instead of conflicting with it. :contentReference[oaicite:4]{index=4} :contentReference[oaicite:5]{index=5}

Another challenge was document processing itself. PDFs are not always easy to work with because extracted text can be messy, incomplete, or inconsistently formatted. That means the backend cannot simply read a file and assume the output will already be useful. It has to be designed to handle imperfect input and still produce something meaningful.

We also faced the challenge of secure AI integration. It is easy to connect an AI model to an app in a simple demo, but doing it properly means thinking about token validation, backend-only API keys, structured prompts, and predictable responses. That required more careful system design than just making a single model call.

Finally, there was the challenge of building under hackathon conditions. Time was limited, and there were multiple moving parts across authentication, file upload handling, parsing, and AI analysis. As a backend developer, we had to focus on building the core pipeline first and making sure the backend architecture could support the product vision, even if every feature was not fully polished yet.

What Makes This Project Meaningful

What made CoverMyPharma meaningful to us was that it addressed a problem with direct human impact. This was not just a technical exercise. It was about reducing confusion and delays in a healthcare process that many people already find stressful. Working on the backend allowed me to contribute to the part of the system that turns raw documents into actionable information, which is where much of the product’s value comes from.

Overall, this project helped me grow as a developer by showing me how backend engineering supports real users, real workflows, and real decision-making. It strengthened my understanding of API design, authentication, document handling, and AI-powered processing, while also reminding me that good backend systems should make complicated things feel simpler for the people using them.