01 / Healthcare marketplace

MDsave

Clearer insurance information. Simpler data operations.

Patient-facing feature development · Internal data tooling

Case study draft

Executive summary

Among the many features I worked on at MDsave, this case highlights two separate projects: an end-to-end deductible checker for patients and a reusable Excel upload engine for internal data operations. The engine combined editable automatic column mapping, RabbitMQ background processing, and emailed XLSX files for failed-row recovery.

At a glance

Deductible checker audience
Patient-facing
Upload engine audience
Internal
Deductible checker contribution
End to end
Upload engine: previous manual effort per hospital
20 hours

Behind the build

Technology stack

The development toolkit and connected services used at MDsave.

RabbitMQ supported background imports; PHPUnit and Codeception supported my unit and functional testing work.

Development & infrastructure

Building, testing, and delivering the product.

  • React
  • PHP
  • PostgreSQL
  • Redis
  • RabbitMQ
  • Jest
  • PHPUnit
  • Codeception
  • Ant Design
  • Storybook
  • WebSockets
  • CircleCI
  • AWS

Services & integrations

External services connected to the platform.

  • Contentful
  • Authorize.net
  • Ribbon Health
  • Prerender.io
  • Salesforce
  • Datadog
  • FullStory

Introduction

MDsave is a healthcare marketplace connecting patients with providers and upfront procedure prices. I worked on many features within that business. This case focuses on two of those contributions, addressing distinct patient-facing and internal needs.

The deductible checker helps patients understand their insurance position. The upload engine helps employees manage large Excel files and add hospital data in batches. The engine is a separate internal tool; it is not part of the checker’s insurance lookup flow.

Feature summary

01

Deductible checker · Insurance details entry

The public form asks for insurance provider, first and last name, member ID, and date of birth.

02

Deductible checker · Deductible progress

The published experience shows individual and family deductible information, including what has been paid and what remains.

03

Deductible checker · A path into care discovery

The surrounding experience explains insurance terms and links to procedures and providers.

04

Excel upload engine · Automatic column mapping

Recognized spreadsheet columns are mapped automatically. Unrecognized columns can be assigned through dropdowns, and automatic selections can also be corrected.

05

Excel upload engine · Background processing

RabbitMQ supports processing large XLSX files in the background, with an in-progress status and an email when the operation finishes.

06

Excel upload engine · Failed-row recovery

Rows with missing required fields or other data issues are collected into a new XLSX file and emailed for correction and re-upload.

07

Excel upload engine · Reusable data workflow

The same reusable workflow could import different data types, beyond hospital additions.

The work

Project 01 · Patient-facing

Deductible checker

Start with the patient’s question

The feature answers a practical question: how much of my deductible is left? I worked on it end to end, bringing that question into MDsave’s patient-facing experience.

The public tool is available without signing up or logging in. It begins with a short insurance-information form rather than requiring patients to navigate a separate account area.

Animated wireframeIllustrative / fictional data
A few insurance details form the entry point to the checker. All values shown are fictional.

Make deductible progress understandable

MDsave describes the result as showing individual and family deductibles, the amount paid, and the amount remaining. These distinctions matter because a family plan can have both individual and family thresholds.

The case focuses on that published information flow. Insurance integrations and implementation details will be added when the technical walkthrough is documented.

Animated wireframeIllustrative / fictional data
After the result, read paid versus remaining amounts, distinguish individual and family thresholds, then carry that context into care exploration. Amounts are fictional.

Connect the result to a next step

The public page continues from deductible information into procedure and provider discovery. It also explains terms such as deductible, copay, coinsurance, and out-of-pocket maximum.

That context helps the checker function as part of the care-shopping journey: understand the insurance position, then explore available care and upfront prices.

Animated wireframeIllustrative / fictional data
Deductible context continues into care categories, an illustrative procedure, and fictional provider listings. No actual quotes or provider data are shown.

Project 02 · Internal operations

Excel upload engine

Address the repetitive operational task

Adding a hospital meant manually entering all of its many data points. That detailed, field-by-field work took employees around 20 hours per hospital, and had to be repeated for each additional hospital.

The upload engine addressed the volume of manual data entry: it let employees bring those data points in through spreadsheets and process multiple hospital records together.

Animated wireframeIllustrative / fictional data
Each hospital required many data points to be entered manually. This field-by-field work took approximately 20 hours per hospital and repeated with each addition.

Recognize the columns, keep people in control

The upload engine automatically recognized spreadsheet columns and selected the corresponding fields. Employees did not have to configure every column from scratch.

When a column could not be recognized, a dropdown let the employee choose the correct field. Automatically selected mappings were editable too, so an incorrect match could be corrected before continuing.

Animated wireframeIllustrative / fictional data
Recognized columns are mapped automatically; unmatched columns use a dropdown, and automatic choices remain editable. Headers and targets are fictional examples.

Process large files without blocking the workflow

Large XLSX files were processed in the background using RabbitMQ. The user could see that the operation was in progress rather than waiting on the upload screen for the entire task.

An email notified the user when processing finished. This made the batch operation an asynchronous workflow with a clear status and completion notification. The 20-hour figure remains the historical manual effort per hospital, not a new processing-time benchmark.

Animated wireframeIllustrative / fictional data
RabbitMQ supports large-file processing in the background. The user sees an in-progress status and receives a completion email. Timing is illustrative.

Return the rows that need attention

During an add or upload operation, a row could have a missing required field or another data issue. The system collected the affected data into a new XLSX file and sent that file by email.

The user could correct just the problematic rows and upload them again. That made recovery a focused correction cycle instead of requiring employees to find the errors themselves across the original large spreadsheet.

Animated wireframeIllustrative / fictional data
Problematic rows are emailed in a new XLSX, corrected, and re-uploaded. All records and issues shown are synthetic.

Keep the engine reusable

Hospital data addition was one application. The engine was designed as a complete, reusable import feature that could add different types of data through the same workflow.

That gave the project a second outcome: beyond streamlining one workflow, it created tooling that could be applied to similar bulk data management needs.

Animated wireframeIllustrative / fictional data
The same engine can import hospital data and other data types. Alternate types shown are generic illustrations.

Impact

Deductible checker: The delivered contribution is an end-to-end patient-facing checker. Its public experience provides a way to understand deductible progress without a login and continue into care discovery.

Excel upload engine: automatic column recognition reduced manual setup, RabbitMQ supported background processing of large files, and emailed failed-row spreadsheets made corrections and re-upload more focused. The previous hospital-addition workflow required around 20 employee hours per hospital.

Reuse was part of the result: the same engine could import different data types rather than serving only hospital additions.

Conclusion

The deductible checker and upload engine were separate projects within my MDsave work. One made insurance information easier for patients to understand; the other streamlined repetitive employee work through reusable data tooling.