Building Medicare Intelligence from Zero

Overview

What is CheckRx

CheckRx is a Medicare intelligence platform that helps insurance agents, agencies, and healthcare organizations navigate plan data at scale. I joined as one of the founding engineers on a 3-person team and built the technical foundation from scratch: data pipelines, APIs, frontend apps, and AI-powered tools serving 500+ agents and 50,000+ daily queries.

Problem

Fragmented Data, Manual Workflows

Medicare is one of the most complex systems in American healthcare. Thousands of plans change every year. Agents spend hours cross-referencing PDFs, spreadsheets, and government databases just to answer a single client question.

The data itself is fragmented. CMS publishes plan details across dozens of files in inconsistent formats. No single tool existed that could ingest all of it, normalize it, and make it queryable in real time.

Research

Shadowing Agents During Enrollment

We spent the first weeks shadowing insurance agents during enrollment season. The workflow was painful: agents toggled between 4 to 6 browser tabs, copied plan details into spreadsheets by hand, and called CMS hotlines for clarifications. A single plan comparison took 20 to 30 minutes.

We interviewed 15+ agents across independent brokerages and larger agencies. Two patterns stood out. First, agents did not need more data. They needed faster answers to specific questions: 'Does this plan cover my client's insulin?' Second, the tools they had (carrier portals, CMS plan finder) were built for consumers, not professionals working at volume.

Infrastructure

Pipelines, APIs, and 50K Daily Queries

I built HIPAA-compliant data pipelines that process CMS Medicare data with inconsistent schemas and missing records. The pipelines pull raw CMS files, normalize across plan types, and load clean data into PostgreSQL on a nightly schedule. The system now serves 500+ insurance agents and 50,000+ daily queries that drive plan recommendations.

I shipped 15+ RESTful APIs and microservices on GCP with Docker and GitHub Actions CI/CD. Deployment went from hours to minutes with 99.9% uptime. The provider network API runs on Go for low-latency, high-concurrency lookups across 1M+ providers.

• Cut plan lookup time from 10 seconds to 200ms through query optimization and Redis caching, letting agents handle 3x more client calls per day. Partitioned tables by plan year and indexed on formulary, provider network, and premium ranges.
• Provisioned and managed all cloud infrastructure on GCP using Terraform. Every environment, staging and production, deploys from the same IaC definitions. No manual console changes.

AI & Agents

Voice Agents That Replace Manual Lookups

I shipped 3 React and FastAPI applications with GPT-4o, LlamaIndex, and RAG pipelines for natural language queries across 5,000+ Medicare plans and 1M+ providers. Instead of searching through plan documents manually, agents ask questions in plain English and get sourced answers in seconds.

The voice agents run on LiveKit and ElevenLabs. They handle plan comparisons and eligibility questions, replacing 10-minute manual lookups. We hit 90% user satisfaction in early feedback, mostly because the agents answer follow-up questions without losing context.

RAG pipelines index plan documents and formulary data into vector stores for retrieval at query time. MCP integrations let agents call external tools like coverage lookups and drug interaction checks mid-conversation.

Decisions

Why Go, FastAPI, and PostgreSQL

We use Go for the provider network API where low latency and high concurrency matter most. Python and FastAPI handle the data pipelines, AI orchestration, and application backends. React and TypeScript run the frontend.

GCP over AWS was a deliberate choice. Our team had deeper GCP experience, and Cloud Run gave us serverless containers without the cold-start pain of Lambda. Terraform made the infrastructure reproducible from day one.

We picked PostgreSQL over a NoSQL option because Medicare data is deeply relational: plans have formularies, formularies have drugs, drugs have tiers and restrictions. Trying to flatten that into documents would have created more problems than it solved. Redis sits in front for hot queries that agents repeat throughout enrollment season.

Products

Tools That Drove Business Outcomes

Reflection

Building Under HIPAA Constraints

CheckRx taught me what it means to build from zero with real compliance constraints. HIPAA is not just a checkbox. It changes how you log, how you store data, and how you think about access control at every layer.

The biggest lesson was about building for domain experts, not general users. Agents think in plan comparisons, formulary tiers, and network adequacy. The closer our tools matched their mental model, the faster they adopted them. Generic dashboards failed. Specific, opinionated workflows won.

If I started over, I would invest in observability earlier. We added structured logging and tracing after the first few production incidents. Having it from day one would have saved us hours of debugging.