I got a 4-star Google review last week that bothered me more than it should have.
A long-time patient wrote that he’d never paid a “copay” at our urgent care clinics before — and this time we charged him $37.50 out of nowhere. He was confused. He felt blindsided.
The review was not really about $37.50. Patients can’t tell a copay (a flat fee per visit, like $25) from coinsurance (a percentage of the bill you owe after insurance pays its share). Honestly, neither could I until I had to learn it running these clinics. When the patient and the clinic are both confused, more words are not the fix. A picture is. So I built one: eob.arcs.health, a free visual tool the front desk walks patients through at check-in.
I called our office manager. She pulled up his account and walked me through it: his insurance carries 25% coinsurance, not a copay. The visit cost $150. Insurance paid $112.50. He owed $37.50. His earlier visits had landed at zero patient responsibility for reasons that had nothing to do with this one — claims denied then reprocessed, or his deductible (the amount you pay out of pocket each year before insurance starts paying) had already been met.
He wasn’t wrong to be confused. The math was right. The surprise was real.
What was actually broken
My office manager said something that stuck: “Patients don’t understand the difference between copay and coinsurance. I try my best to explain it, but most don’t get it.”
I nearly wrote a tighter script for the front desk. That would have been a cleaner way to say the same words, but it would still be telling. Telling was not working for patients, and it had not worked for me either.
This isn’t one review. It’s an operational leak:
- Staff time spent re-explaining benefits, visit after visit
- Patients blindsided by bills they didn’t see coming
- Reviews that chip at the reputation we’ve built
- Collection friction when patients don’t understand why they owe what they owe
I needed to show patients their benefits.
The tool
I built a simple visual tool: eob.arcs.health
The front desk uses it at check-in. Staff walk through four steps while the patient watches the visual breakdown update:
- Visit cost — “Your urgent care visit costs $150”
- Deductible check — “Do you have a deductible? How much is remaining?”
- Insurance coverage — “Your insurance pays 75%, you pay 25%”
- Final breakdown — a big, clear visual showing exactly what they’ll pay today
The key is the animated visual bar that shows the money flowing — insurance’s share filling in one color, the patient’s share in another, growing and shrinking as the numbers change:
the mechanism — how the visual bar actually works give me the detail
The app is a single-page React component with no backend. All state lives in three controlled inputs — visit cost, deductible remaining, and coinsurance percentage — and the bar re-renders on every keystroke. No form submit, no loading spinner, no API call.
The animated fill is a plain CSS transition on width:
.insurance-fill {
width: var(--insurance-pct); /* e.g. "75%" */
transition: width 300ms ease;
background: #4f46e5;
}
.patient-fill {
width: var(--patient-pct);
transition: width 300ms ease;
background: #e11d48;
}The percentages are derived values, not stored state — React recalculates them from the three inputs and passes them as CSS custom properties. The “aha moment” for patients is that the bar moves as the front-desk staff types, so it feels like a live demonstration rather than a form.
Built with Lovable (AI-assisted React + Tailwind scaffolding), deployed to a custom subdomain via Cloudflare Pages in a few clicks, zero server costs. The whole thing is a static HTML export — share it as a URL, bookmark it on an iPad, done.
Try it: open the app, set coinsurance to 25%, then slowly drag the deductible slider from $0 to the full visit cost and watch how the patient’s share grows. That animation is the patient education moment.
Patients can see the $150 visit split between what insurance covers and what they owe. No insurance jargon. Just dollars and percentages.
It is the tool I wanted when I was trying to understand my own insurance.
Why I built it
The commercial tools did not fit the moment I needed to solve.
The commercial options for patient cost estimation are either:
- Too expensive for a small operator
- Too complex — they require full EHR integration (EHR is the electronic health record software that runs a clinic; “integration” means wiring your tool into it, months of work)
- Built for pre-visit estimates, not point-of-service education at the counter
I needed something a front desk staffer could open on an iPad in 30 seconds and use before the patient left. I built it with Lovable in about two hours.
What happened next
I sent the tool to my front desk team this morning and asked for honest feedback:
- Does it actually help, or just add time?
- What’s confusing?
- What’s missing?
If it works, it solves a real problem. If it does not, I will fix it or scrap it. The goal is not perfect software. It is helping patients understand their bills.
I replied to the Google review with a link to the tool and acknowledged that we should have done better. I hope he, and other patients, find it useful.
The tool is free and open for other urgent care operators dealing with the same patient confusion about benefits. I am still iterating, and ideas that would make it better are welcome.
Link: eob.arcs.health