Building Medicare Intelligence from Zero

Overview

What is CheckRx

CheckRx is a Medicare intelligence platform I helped build from scratch as a founding engineer. We started with data pipelines and APIs, then layered on agent tools, a CRM, a voice AI assistant, and a senior-facing conversational product. The team is 5 people (3 engineers), the platform serves 500+ insurance agents, and we handle 50,000+ daily queries. Everything runs on a shared data layer: normalized CMS data, RAG pipelines, and provider/plan APIs that every product consumes.

Problem

Medicare is a Data Problem First

Medicare has thousands of plans that change every year. CMS publishes plan details across dozens of files in inconsistent schemas, with missing records, format changes between years, and no stable identifiers across datasets. Before you can build any useful tool, you need to solve the data normalization problem.

The existing tools were built for consumers browsing a few plans, not professionals comparing dozens of plans per day across formularies, provider networks, and cost structures. Agents were stuck toggling between carrier portals, CMS plan finder, and spreadsheets. The bottleneck was not access to data. It was the absence of a clean, queryable data layer purpose-built for professional workflows.

Research

Shadowing Agents During Enrollment

User research at CheckRx is not a phase. Shadowing agents, sitting on calls, and running interviews are continuous practices that shape every product decision. We started during enrollment season and never stopped. A single plan comparison took agents 20 to 30 minutes across 4 to 6 browser tabs, manual copy-paste, and CMS hotline calls.

We interviewed 15+ agents across independent brokerages and larger agencies. Two insights stuck. First, agents did not want more data. They wanted faster answers to specific questions: 'Does this plan cover my client's insulin at a Tier 2 copay?' Second, every tool they had was designed for consumers, not professionals working at volume. That gap defined our product direction.

Products

Four Products, One Data Layer

Each product built on the same data layer: pipelines, Plan API, Provider API, and RAG system. Agent tools, CRM, and market research live on one platform. AskANA is its own product with its own platform, but powered by the same CheckRx APIs and data infrastructure.

Engineering

Infrastructure Under 50K Daily Queries

HIPAA-compliant data pipelines pull raw CMS files nightly, normalize across plan types, and load clean data into PostgreSQL. 15+ RESTful APIs and microservices run on GCP with Docker and GitHub Actions CI/CD. The provider network API is written in Go for low-latency, high-concurrency lookups across 1M+ providers.

RAG pipelines index plan documents and formulary data into vector stores for retrieval at query time. Voice infrastructure runs on LiveKit and ElevenLabs. Twilio handles multi-channel routing for SMS, phone, and WhatsApp. MCP integrations let AI assistants call external tools like coverage lookups and drug interaction checks mid-conversation.

• Cut plan lookup latency from 10 seconds to 200ms through query optimization and Redis caching. Partitioned tables by plan year and indexed on formulary, provider network, and premium ranges.
• All cloud infrastructure provisioned with Terraform. Every environment deploys from the same IaC definitions. No manual console changes.

Decisions

Why Go, FastAPI, and PostgreSQL

Go for the provider network API where latency and concurrency matter most. Python and FastAPI for data pipelines, AI orchestration, and application backends. PostgreSQL because Medicare data is deeply relational: plans have formularies, formularies have drugs, drugs have tiers and restrictions. Flattening that into documents would have created more problems than it solved.

GCP and Cloud Run gave us serverless containers without Lambda's cold-start pain. Terraform made infrastructure reproducible from day one. Twilio for multi-channel messaging because it is HIPAA-eligible and handles carrier complexity we did not want to build ourselves.

Reflection

What Building from Zero Actually Looks Like

HIPAA is not a checkbox. It changes how you log, how you store data, and how you think about access control at every layer. That constraint shaped every architectural decision from the start.

The biggest lesson was building for domain experts. Agents think in plan comparisons, formulary tiers, and network adequacy. The closer our tools matched their mental model, the faster adoption went. Generic dashboards failed. Opinionated workflows won.

AskANA was the hardest product pivot. Everything we built for agents assumed a professional user who knew Medicare. Rethinking the interaction model for seniors -- simpler language, multi-channel, patience built into the conversation flow -- forced us to question assumptions baked into every layer. If I started over, I would invest in observability earlier. Structured logging and tracing after the first production incidents cost us hours we did not need to lose.