Critical Systems Can’t Stop. They Still Have to Change.
How to keep a live public system current without betting everything on a replacement
By Angus Irvine, Senior Vice President, IdeaCrew
October 2026
When a critical public system goes live, it stops being a project and becomes infrastructure. A state-based marketplace is a clear example. Residents rely on it to apply for coverage, choose a plan, and keep their subsidies. Carriers rely on it to exchange enrollment. During open enrollment it cannot go down, and for the rest of the year it cannot get things wrong. The same is true of eligibility systems, benefits portals, and any other system a public program runs on.
But nothing around those systems stands still. Federal rules change: pre-enrollment verification and the Medicaid community engagement requirements are rewriting what marketplaces and Medicaid systems must do over the next two years. Residents expect to do everything from a phone. And the technology underneath ages whether or not anyone touches it. A system that went live ten years ago was built for a world that no longer exists.
So, every agency with a critical system eventually faces the same question: how do you change something that cannot stop?
Two ways to keep up
The first is periodic replacement. The system runs largely unchanged until it can no longer keep up, and then the agency procures a new one and cuts over. Sometimes that is the right call, and we have led such transitions ourselves.
But replacement carries costs that are easy to underestimate. Two systems have to run side by side. Years of data have to be migrated, often into a system with different rules. Staff and residents have to learn something new all at once. And while the replacement is being built, which can take years, the old system is often frozen, so new needs pile up waiting for the new platform. The risk is concentrated on a single cutover date, usually close to a deadline that cannot move.
The second path is continuous evolution: changing the system one part at a time, while it stays live, so it never falls far enough behind to need replacing. This has costs too. It requires steady investment rather than a large one every decade, and an architecture that lets parts change independently. But it spreads the risk across many small, reversible changes instead of one large, irreversible one.
What evolution looks like in practice
The shared marketplace platform we operate for the District of Columbia, Massachusetts, and Maine first went live in 2014, serving DC Health Link. Since then, nearly every major part of it has been rebuilt while it stayed in service. Four changes show how.
A new face on the same engine. We redesigned and rebuilt every user-facing interface on top of the existing back-end components. The rules that determine eligibility and enrollment did not change, so the highest-risk part of the system stayed stable while the part residents actually see was completely modernized. The rebuild covered consumer, broker, assister and agency staff portals, and we rolled it out in stages to maximize end user experience improvements while minimizing delivery and change management risk around critical health insurance lifecycle periods like open enrollment and tax filing deadlines.
Taking the monolith apart. Like most systems of its generation, the platform began as a single application that did everything. Over a couple of years, we refactored it into an ecosystem of integrated components, each with a clear job and a defined interface to the others: eligibility, enrollment/plan shopping, notices, EDI/trading partner transactions, and reporting/data analytics. Residents never saw this change. But it made the system far easier to maintain and to build on, since any one component can now be updated or replaced without disturbing the others. It was also the most important one we made, because it made the next two possible.
Swapping out an engine. Notices are among the most consequential things a marketplace produces: they tell residents what they qualify for, what they owe, and what they need to do next. Once notices were their own component, we could replace the notice technology entirely, behind a stable interface, without touching eligibility or enrollment. The new engine also changed who controls the words. Agency staff can now update notice language themselves, for renewals or policy changes, with no code change, no deployment, and no release. That was not possible when the platform was a single application, where every wording change was a software change, and notice changes or additions that used to take weeks can now take days or hours.
New work on new parts first. We are now replacing the components that process EDI, the enrollment transactions exchanged with insurance carriers. Rather than rebuilding everything and cutting over, we built the new EDI module to handle new marketplace products first. Once it was running and proven in production, we began the process of moving products from the existing EDI solution to the new one, while they both run in parallel. Each migration moves work onto a component already known to work, and the old path keeps running until the last product has moved.
When replacement is the right answer
Evolution is where we start, and we hold to it where the architecture allows. But some systems cannot be evolved. A platform may no longer be supported, it may be built in a way that cannot be changed safely at any speed, or a contract may simply come to an end. When that is the case, the work is to run the replacement well rather than to avoid it. We have led those transitions, including CoverME.gov, where Maine moved off the federal marketplace and launched its own in eight months. The state had decided to run its own exchange end to end, and you cannot evolve your way off a platform you do not own. A new system was the only path. Because CoverME.gov launched on our shared platform, Maine’s replacement landed on a system built to keep evolving.
What carries over to any system
None of these changes is specific to health insurance. The principles behind them apply to any critical system an agency runs.
Change one layer at a time. Keep what works stable while you replace what does not, so there is always a known-good foundation to fall back on.
Make the enabling investment first. Breaking a system into components is rarely the most visible project, but it makes every later change cheaper and safer.
Prove new components on new work. Let a new part earn trust on work with no legacy to protect, then move existing work onto it.
Keep the old path running until the new one is proven. A change that can be reversed is a change that can be made safely.
Plan to the program calendar, not the vendor’s. Major changes land outside open enrollment, renewals, and other key operational dates.
What this means for agencies
Most agencies will face a replacement decision at some point, and some are facing one now. The lesson is not to avoid replacement. It is to make sure whatever you choose next can evolve, so that this replacement is the last one you need. A few questions are worth asking of any platform or proposal:
Can individual components be replaced without replacing the whole system?
Are the interfaces between components documented, and does the agency have the rights to use them?
Does the contract fund ongoing evolution, or only operations and maintenance?
What has the vendor actually replaced inside a live system, and what did residents experience while it happened?

Why this matters to us
Our marketplace platform has served residents for more than a decade. It is still current not because it was built perfectly in 2014, but because it has never stopped changing. That is the standard we think public systems should be held to: not a system that never changes, but one that never has to be replaced all at once.
Oct 30, 2026