How to Build Medical Billing Company Software

A medical billing company processing claims for 50 provider practices deals with 200 or more claim denials every day. Each denial carries a specific reason code, and each reason code demands a different action: appeal, recode and resubmit, or write off. Without a system that routes denials by code and tracks resolution status, revenue leaks silently. The provider clients notice late. By then, some of those claims are past timely filing deadlines and unrecoverable.

According to the American Medical Association's Physician Practice Benchmark Survey, administrative tasks including claim denials cost physician practices an average of $82,975 per physician per year. Billing companies exist to absorb that cost. But they can only do it profitably with software that automates the routing work.

What medical billing company software does

Charge entry: Staff enter or import charges from provider notes. Each charge captures the CPT code, ICD-10 diagnosis code, rendering provider NPI, date of service, place of service code, and submitted amount.

EDI claim submission: The system generates 837P transactions for professional claims and 837I for institutional claims. Claims route through a clearinghouse (Waystar, Change Healthcare) before reaching the payer.

ERA/EOB posting: When the payer responds, the 835 transaction maps payment to individual service lines. The posting engine records paid amounts and creates CO-45 contractual adjustment records for the difference between submitted and allowed amounts.

Denial management workflow: Denied claims create work items. The system assigns each work item to a staff queue based on the denial reason code and payer. Staff track status from unworked through in-progress, appealed, and resolved.

Patient statement generation: For balances transferred to patient responsibility (PR codes), the system generates patient statements via print or digital delivery.

AR aging reports: Aging buckets (0-30, 31-60, 61-90, 90+) broken down by payer and by provider client. The billing company's management sees this across all clients. Each provider client sees only their own data.

Payer contract management: Fee schedules per payer per provider client. The system flags underpayments when the paid amount on a service line falls below the contracted rate.

Multi-provider client management: Each provider client is a separate record. Billing staff are assigned to clients. All reports filter by client by default.

MVP vs. full platform

Most billing companies need to validate the core workflow before committing to the full feature set. An MVP gets you to revenue faster and tells you which advanced features actually matter to your clients.

MVP (15-22 weeks, $160K-$270K):

• Charge entry with CPT and ICD-10 codes

• EDI 837P/837I claim submission via clearinghouse

• ERA/835 posting with CO-45 adjustments

• Denial tracking with reason code and status

• AR aging reports by payer and provider

• Multi-provider client management with role-based access

Full platform (26-36 weeks, $320K-$510K), adds:

• Payer credentialing tracking and expiration alerts

• Prior authorization management with status tracking

• Patient payment portal with online statement delivery

• Automated patient statement delivery (print mail integration)

• Revenue cycle analytics dashboard with KPIs per provider client

• Provider performance benchmarking across the billing company's portfolio

Core architecture

The claim record stores: provider NPI, patient demographics, date of service, procedure codes (CPT), diagnosis codes (ICD-10), place of service, submitted amount, allowed amount, paid amount, and current status.

Every status change on a claim writes to a transaction log with a timestamp and the user who made the change. This log is the audit trail required for payer audits and HIPAA compliance.

ERA posting works like this: the 835 transaction arrives from the clearinghouse. The posting engine reads the payer claim number (CLM01 segment) from the ERA and matches it to the original claim in the database. Each service line in the ERA maps to a procedure line on the original claim by line item control number. The engine updates paid amounts and writes adjustment records for CO-45 (contractual discount) and any other adjustment reason codes present.

The denial record schema: claim_id, denial_date, denial_reason_code (e.g., CO-97, CO-4, PR-1), denial_category (billing error, eligibility, authorization, duplicate), assigned_user, status (unworked, in progress, appealed, resolved, written off), timely_filing_deadline, days_until_deadline.

The hardest technical challenge: denial routing at scale

Denial routing and resolution tracking at scale is where most billing software fails.

A billing company working for 50 providers processes around 10,000 claims per month. According to MGMA research, denial rates from certain payers run 15-25%. That is 1,500 to 2,500 denials per month. Each denial code requires a specific action, and routing them manually is where revenue gets lost.

Consider three common codes:

• CO-97 (bundling issue): requires a CPT unbundling review and possible modifier addition before resubmission.

• CO-4 (modifier required): requires the correct modifier added to the original procedure code, then resubmission.

• PR-1 (patient deductible): requires a patient statement, not a payer appeal. Sending this to an appeal queue wastes time.

The solution is a denial routing table. Each row maps a denial_code plus payer_id to an action_template and a skill_level. The action_template describes the steps required (appeal type, resubmission steps, days to act). The skill_level maps to a staff queue (entry, intermediate, senior).

When the ERA posting engine creates a denial record, it looks up the routing table and assigns the denial to the correct queue. The work item appears in the right staff member's queue with the action steps pre-populated.

Timely filing complicates this further. Medicare allows 90 days from the date of service. Commercial payers vary from 60 to 365 days. Every denial record must store the timely_filing_deadline for the claim's payer. A background job runs nightly, calculates days_until_filing_deadline for every open denial, and sets an escalation flag on any denial within 14 days of that deadline. Escalated denials jump to the top of the queue and notify the supervisor.

Without this automated escalation, a billing company running 2,000 open denials will miss deadlines consistently. Revenue is not recoverable after timely filing expires.

"The single biggest revenue leakage point in billing company operations is denied claims that age out of the timely filing window. Every day without automated escalation is money you cannot recover." -- Chad Anguilm, Vice President of Growth, Medical Advantage Group, speaking at the MGMA Annual Conference

RaftLabs has built healthcare revenue cycle platforms where denial routing and timely filing escalation are treated as first-class features, not afterthoughts. The billing companies that scale past 50 provider clients are the ones with automated routing in place from day one.

Build costs and timeline

MVP:

• 15-22 weeks

• $160,000-$270,000

• Team: 1 backend engineer (Node.js, EDI), 1 frontend engineer (React), 1 QA engineer, 1 part-time project manager

• Includes: charge entry, claim submission, ERA posting, denial tracking, AR aging, multi-provider management

Full platform:

• 26-36 weeks

• $320,000-$510,000

• Adds: prior auth management, credentialing tracking, patient portal, automated statements, analytics dashboard

Ongoing infrastructure:

• $3,000-$8,000 per month

• Clearinghouse API fees (Waystar, Change Healthcare) are typically per transaction or monthly volume tiers

• HIPAA-compliant hosting, encrypted storage, BAA with cloud providers

Build vs. buy

Kareo (now Tebra): $300-$500 per month per provider. Good for solo practices. Denial management is basic. Multi-provider billing company workflows are not its primary use case.

AdvancedMD: $1-$3 per claim or flat-rate plans. Full PM system. Better denial tracking than Kareo, but the reporting is provider-practice-centric. Hard to run cross-provider client AR reporting without exporting to a spreadsheet.

Athenahealth: Charges a percentage of collections (typically 4-8%). Works well for large health systems. Not cost-effective for a billing company managing independent practices, and customization is limited.

CollaborateMD: $150-$500 per month. Purpose-built for billing companies. Denial management is functional. Custom denial routing logic and provider-benchmarking analytics require building on top of their export data.

Build when your billing company manages 10 or more provider clients and needs denial routing logic that matches your specific payer mix, plus multi-provider AR reporting that generic PM systems cannot produce without manual work. The operational efficiency gains at scale justify the build cost within 12-18 months.

Tech stack

Backend: Node.js with PostgreSQL. The relational model handles claim-to-ERA matching, denial routing lookups, and AR aging queries well. PostgreSQL's native JSON support handles variable payer contract structures without schema migrations.

EDI processing: Use the node-x12 library for parsing and generating 837/835 transactions, or integrate directly with a clearinghouse API (Waystar or Change Healthcare). Clearinghouse APIs simplify EDI generation but add per-transaction costs.

Frontend: React with role-based views. Billing staff see their assigned denial queues. Practice managers see their practice's AR only. The billing company's operations team sees the full cross-provider dashboard.

Storage: AWS S3 for claim documents, EOB images, and ERA files. Encrypt at rest with KMS.

Notifications: SendGrid for denial status updates to provider clients. Twilio SMS for escalation alerts to billing supervisors.

Auth: Auth0 or Cognito with role-based access control. Roles: billing staff, senior biller, practice manager (provider client), billing company admin.

Compliance: All data encrypted at rest and in transit. BAA required with AWS, SendGrid, and any clearinghouse API provider. Audit logs retained for 7 years per HIPAA requirements.