Healthcare application modernization
The clinical logic in a legacy EHR is usually the part worth keeping. The platform underneath it is the problem. Modernization means decoupling the two, not rewriting both at once.
- 6Business objectives
- 94Work orders
- 6Governed stages
Six reasons health systems modernize off legacy platforms
The pressure is rarely that the software stopped working. It is that the people who can safely change it are disappearing while the compliance deadlines are not.
The talent pool is the real deadline
MUMPS and Delphi both carry very small and shrinking developer communities. Every year the estate stays as it is, the pool of people who can change it safely gets smaller and the key-person risk concentrates further.
Clinicians are locked to one platform
A Windows-only desktop client means clinicians on Mac, Linux, or tablets need workarounds to do their jobs. A browser-based client removes the workaround rather than documenting it.
Interoperability deadlines carry penalties
FHIR R4 certification is a compliance requirement with real financial exposure, not a roadmap item. Systems with no FHIR code path at all need that work scoped honestly rather than assumed.
No pipeline means no safety net
Estates with no CI/CD rely on manual test execution, so every change is a judgement call. Automated validation on each pull request is what makes incremental modernization survivable.
Supply chain risk is invisible
Dependencies without automated auditing or a committed lockfile can carry known CVEs that nobody has looked for. Scanning in the build is the difference between knowing and hoping.
Clinical logic is the asset
Decades of encoded clinical rules are why the system is trusted. Modernization should preserve that logic and replace the platform around it, which is exactly what a rewrite risks losing.
What changes when you modernize incrementally
Nothing is replaced wholesale. The core stays running while access to it changes, one workflow at a time.
- 01
An API layer in front of the core
REST, GraphQL, and FHIR endpoints wrap the existing core so modern clients can reach clinical logic without that logic being rewritten. New features get built against the API in mainstream languages instead of the legacy one.
- 02
The client migrates behind feature flags
A Strangler Fig pattern keeps the legacy desktop client and the new web client running side by side against the same data, with feature flags controlling which workflows route where and clinical review gating each cutover.
- 03
Authentication moves to modern standards
OAuth2 and SMART on FHIR for external clients, mTLS between the API layer and each site, and a credential vault mapping modern identities onto legacy access codes, with every call logged.
- 04
Deployment becomes reproducible
Containerized test environments and pipeline validation on every pull request replace manual test runs, so changes to a system serving live clinical workflows can be verified before they land.
How healthcare modernization works
From import to verified output, every step is scored, specified, and tracked.
Import the estate
The codebase is ingested as it is, including the legacy core, the desktop client, and any modern sub-projects already in flight. No prior documentation required.
Score and assess
Scored across eight engineering-health dimensions, with recommendations tied to specific evidence in specific files rather than general advice about legacy systems.
Reconstruct the specification
Clinical rules encoded in the legacy core are reconstructed into a specification your compliance and engineering teams both review, before any replacement is designed.
Design the target architecture
API topology, authentication strategy, site adapters, and the migration pattern are decided and recorded as binding requirements rather than discovered during implementation.
Break down work orders
Dependency-ordered work orders with acceptance criteria, sequenced so the foundational pipeline work lands before the changes that depend on it.
Verify and ship
Automated validation gates each change, and work orders connect into Claude Code, Cursor, Windsurf, and other MCP-compatible editors so the governed spec travels with the engineer.
From finding to work order
Every import is scored across eight engineering-health dimensions, then broken into dependency-ordered work orders. Here is what the first one looks like.
ForgeScore findingHigh severity finding
Trust BoundariesHigh
Security and dependency auditing. No evidence of automated scanning tooling in the repository, and a JavaScript sub-project carrying runtime dependencies without lockfile evidence.
Modernization work orderBuild
WO-001 · Pull request validation pipeline
Stand up automated validation on every pull request as the foundation the rest of the modernization depends on. Critical and high severity dependency vulnerabilities block merge, with audit results posted back as review comments. Unblocks the containerized test environment and the audit stages that follow it.
Common challenges
Forge surfaces the decisions a healthcare modernization tends to defer. These came out of the approved specification as open questions rather than surprises mid-migration.
Clinical safety gates every cutover
Routing a workflow from the legacy client to the new one is a clinical decision, not just a deployment. Who reviews and approves each cutover has to be settled before the first flag is flipped.
Multi-site topology shapes the API
Health systems often run one instance per site rather than one central system. Whether adapters sit co-located per site or behind a central gateway changes the architecture and needs deciding early.
Interoperability scope is unresolved
Which FHIR resources to certify first, and whether legacy HL7 v2 interfaces stay in parallel, determines both the timeline and the compliance exposure. Flagged before implementation begins.
Legacy identity has to be bridged
Modern identity standards do not map cleanly onto legacy access and verify codes. The credential bridge between them is a security design decision, not a configuration detail.
Frequently asked questions
Do we have to rewrite the legacy core?
No, and that is the point. The core stays running while an API layer is placed in front of it. Clients migrate one workflow at a time against that API, so the clinical logic your organization trusts is preserved rather than reimplemented.
How does this work when we have no documentation?
Missing documentation is the normal starting condition for a legacy healthcare estate. Forge works from the source itself and reconstructs the rules into a specification your team reviews before anything is replaced.
Can clinicians keep working during the migration?
Yes. The Strangler Fig pattern keeps the legacy client and the new one running against the same data, with feature flags controlling which workflows route where. Cutover happens per workflow, with clinical review, rather than as a single switch.
What about HIPAA and interoperability requirements?
Selecting the healthcare industry preset configures HIPAA, HITECH, and HL7 or FHIR policies, which then attach to the artifacts generated at each stage. Certification scope is confirmed with your compliance team rather than assumed.
Where does the work actually start?
With the pipeline. Automated validation, containerized test environments, and dependency auditing land first, because incremental modernization of a live clinical system is only safe if every change can be verified before it ships.
Other new application paths
Ship enterprise software at AI speed.
Every modernization path is spec-first and governed from Day 0.