The App Nobody Wanted to Touch

  • Onboarding: 12 min to 3 min
  • Full rewrite approved same quarter
  • No 3-week regression cycles
  • 12 to 3 min Patient onboarding time
  • 90% Reduction in onboarding-related billing errors
  • 4 weeks Time from engagement to working proof module

What we walked into

An Australian healthcare administration company with 120 employees was running its core operations on an internal tool built five years earlier by a developer who had since left. The application handled patient onboarding, appointment scheduling, billing, and insurance claims processing for a network of 14 clinics. Nobody fully understood the codebase. Adding any feature took weeks of careful testing because changes in one module frequently broke others, and there were no tests to catch the breakage before it reached production. The team had stopped trying to improve the application and learned to work around it instead, and every workaround quietly widened the gap between what the system recorded and what was actually happening on the clinic floor. Sticky notes and shared spreadsheets filled that gap, and the staff who maintained them had quietly become the real source of truth.

What they told us

I stopped trying to explain why we needed a new system. I just showed them. Four weeks of working software did what two years of proposals could not.
FatimaCTO, Australian Healthcare Administration

What was actually broken

The application was a monolithic PHP codebase with no automated tests, no documentation, and a database schema that had been altered so many times that several tables carried contradictory column names for the same field. The original developer had written everything on a custom, undocumented framework that bore no resemblance to Laravel, Symfony, or any convention a new hire would recognize, so none of the usual mental models applied. New developers spent their first three months just learning how the application worked before they could safely change a single line, and onboarding a senior engineer to this kind of bespoke system routinely runs into months rather than weeks. Two developers had quit within their first year, citing the codebase as the primary reason. The knowledge that did exist lived in people, not in the repository, and it walked out the door every time someone resigned.

The CTO had been advocating for a full rewrite for two years. She had produced three separate proposals, each with cost estimates, timelines, and risk assessments. Leadership rejected all three. The first was rejected because the estimated cost was too high. The second was rejected because the estimated timeline was too long. The third was rejected because two earlier rewrite attempts, both before the CTO joined, had already failed. That history is not unusual: big-bang rewrites are one of the most common ways modernization efforts collapse, because they demand the entire system be rebuilt before the business sees any value, and they frequently overrun their estimates. The word "rewrite" had become politically toxic. Leadership heard it and thought of sunk budget, slipped dates, and broken promises, and no spreadsheet was going to change that association.

Meanwhile, the operational cost kept compounding. Patient onboarding, the most-used workflow, required staff to enter data across seven different screens, wait for three separate validation checks, and manually fire two API calls to external insurance verification services. The process took an average of 12 minutes per patient, against an industry norm where manual intake and transcription typically run 10 to 20 minutes and carry a real error rate at every keystroke. At peak hours, clinics had patients queued in the waiting room with nowhere in the system to put them. Staff had improvised: they skipped optional fields, batched insurance verifications to the end of the day, and tracked anyone left in limbo on a shared spreadsheet of "partially onboarded" patients. Each shortcut traded a few seconds at the desk for a data-quality problem downstream, and those problems cascaded straight into billing. Demographic and technical entry errors are a leading cause of claim denials industry-wide, and here they showed up as rework: the billing team spent 15 hours per week correcting mistakes that had originated in onboarding.

Step by step

Workflow audit and module selection

We spent four days mapping every workflow in the application: onboarding, scheduling, billing, claims, and reporting. For each one we measured usage frequency, time-per-task, and error rate, so the choice of where to start would be a number, not an opinion. The right first slice in a modernization is the one that is high-volume, high-pain, and cleanly isolatable, and onboarding scored highest on all three: the highest frequency (200+ per day across 14 clinics), the highest time-per-task (12 minutes), and the highest error rate (18% of records required manual correction). It was also a clean seam, decoupled enough from scheduling and claims to be rebuilt on its own. We selected onboarding as the proof module precisely because fixing it would be the most visible and the least risky.

Parallel proof module

Rather than touch the existing application, we built a standalone onboarding module in React and Supabase that ran alongside the legacy system, a deliberately small version of the strangler-fig approach: grow the new system next to the old one and let it take over one workflow at a time instead of replacing everything at once. The new module read from and wrote to the same database, so it stayed fully compatible with the rest of the application and never forked the data. Staff toggled between the old and new onboarding interfaces with a single switch, which gave us a built-in rollback: if the new flow misbehaved, anyone could fall back to the legacy screen instantly, with no deploy and no data loss. That meant we could put real software in front of real clinics without betting operations on it. If it did not work, staff would simply stop using it, and nothing would break.

Workflow redesign

The seven-screen flow collapsed into a single-page form with progressive disclosure, so staff saw only the fields that mattered at each step instead of paging through screens looking for the next required box. Insurance verification fired automatically the moment an insurance ID was entered, replacing the manual API call that staff used to defer to the end of the day. Validation moved inline, catching missing fields and bad insurance numbers at the point of entry rather than in three separate batch checks after the fact, which is exactly where the industry data says errors are cheapest to fix. The "partially onboarded" spreadsheet was replaced by a proper status field on the record itself, so the workaround stopped being a parallel system. The redesigned workflow took an average of 2 minutes and 40 seconds, down from 12 minutes.

Deployment and business case

We deployed the proof module to two clinics first, then rolled it out to all 14 over two weeks. Adoption needed no mandate: the new interface was visibly faster, so staff switched to it on their own. Within the first week the two pilot clinics reported zero onboarding backlogs and a 90% reduction in billing errors originating from onboarding. Because we had captured the baseline before launch, the improvement was a measured trend line rather than a claim. The CTO walked leadership through those numbers with a live demo of the working software, the one thing two years of written proposals had never been able to show. The full rewrite was approved that same quarter, scoped against the proof module's actual cost rather than a theoretical estimate, which is precisely why the budget finally held up to scrutiny.

What changed

Patient onboarding time
12 to 3 min
Reduction in onboarding-related billing errors
90%
Time from engagement to working proof module
4 weeks
Onboarding backlogs at pilot clinics
0
Full rewrite approved
Same quarter
Billing correction time eliminated
15 hrs/week

12 to 3 min Patient onboarding time

Get in touch

Tell us what you want built. We tell you where to start and what it takes.

Common questions, plain answers

Why build a parallel module instead of a full rewrite from the start?

A parallel module proves viability with minimal risk. If it fails, the existing system keeps running untouched and you have lost a few weeks, not a quarter. If it succeeds, it produces something a proposal never can: real before-and-after numbers from production, so the business case for the full rewrite writes itself. This approach works especially well when leadership has been burned by previous rewrite attempts, because it lets them fund one small, reversible slice and judge the result before committing to the rest. It is the strangler-fig idea applied to budget approval, not just to code.

How do you ensure the new module stays compatible with the legacy database?

The new module reads from and writes to the same database using the same schema as the legacy app. We add new columns where we need them but never rename or modify existing ones, so the old code keeps finding its data exactly where it expects. Compatibility is verified as part of every deployment, and because both systems share one source of truth there is no sync job to drift and no second copy of the data to reconcile. The legacy application continues to work exactly as before, which is what makes the toggle and the instant rollback safe.

What if the legacy database schema is too messy to work with?

In this case the schema was messy but functional, so we worked with it directly. When a schema is genuinely unusable, we build an adapter layer, an anti-corruption layer, that translates between the legacy structure and a clean internal data model, so the new code reasons about well-named, consistent entities while still reading and writing the legacy tables underneath. It adds a translation seam to maintain, but it preserves full compatibility and keeps the messy schema from leaking into the new system.

How long did the full rewrite take after the proof module?

The full rewrite was scoped as a series of sequential sprints, each one retiring a single legacy module the same way onboarding was. Scheduling went next, then billing, then claims, with each module proven in parallel and toggled over only once its numbers held. The total timeline was approximately six months, delivered in 30-day increments that each ended with working, deployed software rather than a status update. Sequencing it this way meant the legacy system was always fully operational, value landed every month, and there was never a single high-stakes cutover to fear.

ByFounder and Imaginator

Published