PolicyPulse

PolicyPulse delivers pharmacy-level clarity on medical benefit drugs, turning fragmented payer policies into an AI-powered matrix for instant and precise coverage insights with NLP PulseBot for Q&A.

Comment

Inspiration

We built PolicyPulse to tackle a persistent problem in healthcare: the complexity and fragmentation of medical benefit drug coverage policies. Providers and analysts often waste hours searching through hundreds of PDF documents to determine prior authorization requirements, step therapy rules, and site-of-care restrictions. We wanted to create a single, AI-powered platform that transforms these dense policies into a searchable, interactive Coverage Matrix, enabling instant access to actionable insights.

Our inspiration came from seeing firsthand how fragmented and complex medical benefit drug policies are. Health plans constantly change coverage rules, and providers spend hours navigating dense, inconsistent documents. We realized that by combining structured data with AI, we could turn this chaos into clarity, giving healthcare teams instant, accurate answers and freeing them to focus on patient care rather than paperwork.

What it does

Policy Pulse transforms the way healthcare teams navigate medical benefit drug policies.

It:

Centralizes fragmented policies – ingests and normalizes medical policy documents from multiple health plans.

Creates a searchable Coverage Matrix – instantly compare which drugs are covered, under what conditions, and how policies differ across payers.

Provides an AI assistant, PulseBot – answers natural language questions like: “Which plans cover Drug X?” “What prior authorization criteria does Plan Y require for Drug Z?” “What changed across payer policies this quarter?”

Delivers accurate, grounded insights – the AI only responds based on verified policy data, reducing errors and saving teams hours of manual research.

Optimizes for usability and performance – high-density data visualizations run smoothly, with a polished Glassmorphism interface for a premium SaaS experience.

How we built it

Frontend – The Glassmorphism Interface -Designed a premium, next-generation SaaS UI, moving away from standard data tables to a high-contrast, biological-themed interface.

  • Framework: Next.js (App Router) for high-performance routing and server-side rendering.
  • Styling: Tailwind CSS with backdrop-blur filters, semi-transparent backgrounds (bg-white/10, bg-slate-950/40), and subtle borders to simulate frosted glass.
  • Component Library: Shadcn UI (built on Radix UI primitives) for Matrix tables, Dialog modals, and Cards.
  • Typography: Outfit, a geometric sans-serif font for a modern, clinical aesthetic.
  • Icons & Visuals: Lucide-React for iconography, plus a high-resolution particle DNA background to reinforce the medical/biotech context.
  • Markdown Rendering: react-markdown customized with CSS overrides to ensure AI responses are single-spaced and professionally formatted for dark mode.

Backend – The Python Logic Engine

  • Framework: FastAPI (Python), chosen for asynchronous capabilities and native JSON support to handle large medical formulary datasets.
  • Data Structure: Medical policies stored in a structured JSON database, enabling O(1) lookups and clean context windows for AI queries.
  • Server: Uvicorn, a lightning-fast ASGI web server, powering the API. Logic: Handles filtering and searching of the Coverage Matrix and manages Context Injection for PulseBot to ensure AI responses are grounded in verified policy data.

AI Integration – Policy Copilot (PulseBot)

  • OpenAI API: GPT-4 Turbo (or GPT-4o) powers PulseBot to answer coverage questions.
  • RAG-Lite (Retrieval-Augmented Generation): Backend injects the specific JSON database into every AI session, so answers are based on actual policy data.

System Prompt Engineering: - Data Grounding: AI must respond with “I do not have that information” if a drug isn’t in the
JSON. - Formatting: Responses are clean, single-spaced Markdown with bolded headers to match PolicyPulse design. - Conciseness: AI synthesizes data across multiple payers without repeating redundant information.

Data Handling

  • Ingested and normalized medical policy PDFs into JSON ourselves.
  • Extracted coverage criteria, prior authorization rules, step therapy, and site-of-care restrictions for all
    drugs across multiple payers.
  • Ensured both the Coverage Matrix and PulseBot provide instant, reliable, and scalable results.

Challenges we ran into

  • Data Complexity: Each payer uses different terminology and formatting; normalizing policies into a consistent JSON schema required careful planning.
  • AI Accuracy: Preventing hallucinations in PulseBot was critical. We experimented with prompt engineering and context injection to ensure AI answers were grounded in verified data.
  • UI Performance: Rendering hundreds of rows with Glassmorphism effects required optimizations like sticky columns and GPU-friendly CSS to maintain 60fps.
  • Time Constraints: With just a hackathon timeline, we had to balance feature depth, performance, and UI polish while delivering a usable demo.

Accomplishments that we're proud of

  • Built a fully functional Coverage Matrix that consolidates hundreds of medical policies from multiple payers in real time.
  • Developed PulseBot, an AI-powered NLP assistant that answers natural language questions accurately and quickly.
  • Implemented Glassmorphism UI with responsive design, interactive tables, and a premium, biotech-themed aesthetic.
  • Achieved high performance and scalability—even with hundreds of drugs and dozens of payers, the platform remains smooth and reliable.
  • Ensured AI accuracy with RAG-Lite and strict system prompts, preventing hallucinations and providing fact-based answers.
  • Handled complex data normalization ourselves, converting messy policy PDFs into structured JSON for instant queries.

What we learned

  • AI + structured data integration: Learned how to ground AI responses in verified datasets for reliable results.
  • Frontend design at scale: Gained hands-on experience designing a high-density, premium UI without sacrificing performance.
  • Backend optimization: Learned to build asynchronous APIs with FastAPI and Uvicorn to manage large, structured datasets efficiently.
  • Team collaboration: Learned to divide frontend, backend, and AI responsibilities while maintaining a cohesive product under tight deadlines.

What's next for PolicyPulse

  • Expand coverage: Add more payers and continually update policies to reflect the latest changes. Enhance PulseBot intelligence: Incorporate advanced summarization, comparisons, and proactive alerts for policy updates.
  • Integrate analytics: Offer insights on policy trends, approval rates, and payer differences over time.
  • Mobile-friendly version: Make Policy Pulse accessible on tablets and mobile devices for on-the-go healthcare professionals.
  • User feedback loop: Collect insights from healthcare teams to improve UI/UX and AI response accuracy.

Built With

  • css
  • dataparsingscripts
  • fastapi
  • git/github
  • glassmorphismui
  • javascript/typescript
  • json
  • lucide-react
  • markdown/css
  • next.js
  • openaigpt4turbo/gpt4o
  • python
  • rag-lite
  • react-markdown
  • shadcnui
  • tailwind
  • uvicorn
Share this project:

Updates