By Doug Knesek
Introduction
Citizens expect government agencies to deliver public services efficiently, adapt quickly to changing policies, and use taxpayer dollars wisely, all while providing services through familiar and intuitive interactions. Despite significant investments in modernization and process improvements, inefficiencies, delays, and escalating costs persist. Beneath many of these challenges lies a pervasive but often-overlooked issue: software systems that are difficult to change and modernize.
Agile methodologies, when applied well, offer a powerful framework for delivering well-tested software that meets immediate user needs. However, in practice—particularly as implemented by what some call the “Agile Industrial Complex”—teams often focus narrowly on delivering functional software to address current needs, neglecting the core purpose of software: to provide functionality that is cheap and easy to change. Since 70–90% of a system’s lifecycle involves ongoing updates, insufficient discipline around option-enabling architecture and design can rapidly turn these necessary changes into a costly and complex nightmare after the initial release.
Based on our extensive experience working with government systems, we’ve observed that statutes and policies rarely disappear. Often, rules remain on the books—and in systems—but lose practical relevance. For example, Medicare once had more than 500 validation rules for certain claims, yet 400 no longer applied to any real cases. By recognizing this, we eliminated 80% of those rules, streamlining the system without compromising compliance.
One of the biggest, often ignored, challenges is not just the inability to add new capabilities or policies but the inability to remove obsolete ones. As Jennifer Pahlka aptly describes in Recoding America, these “layers of paint” accumulate over time, leaving systems burdened with unnecessary complexity. In this article, we explore how inflexible systems exacerbate government pain points and how prioritizing adaptability can transform the way agencies deliver value.
Key Characteristics of Inflexible IT Systems in Government Agencies
Understanding the traits of inflexible IT systems is crucial for government agencies striving to improve efficiency and adaptability. These rigid systems not only slow down the integration of new features but also perpetuate outdated processes and policies, creating a costly cycle of inefficiency. Some of these inflexible traits include:
Hard to Add or Remove Features: Introducing new policies, workflows, or technologies often requires costly, complex modifications and extensive—often manual—regression testing.
Accumulation of Obsolete Rules: Agencies struggle to remove outdated policies, processes, and technologies, leading to inefficiencies and “layers of paint.”
Poor “Change Experience”: Internal and external users requesting changes encounter slow, cumbersome bureaucratic processes that discourage requests or timely follow-through.
When systems can’t adapt—or shed unnecessary complexity—they create cascading challenges for agencies, ultimately impeding their ability to serve the public effectively.
What are the Government IT System Flexibility Challenges?
Government IT systems often struggle with inflexibility and resistance to change, which impedes their ability to evolve alongside users’ needs. This rigidity stems from procurement issues, agency priorities, and implementation challenges, resulting in systems that become costly and cumbersome over time. Below, we break down three major challenges:
1. Procurement Pitfalls: Misconceptions About Adaptability in Government Software Solutions
Procurement processes further compound these challenges.
Assumption of Flexibility
RFPs (Requests for Proposals) frequently assume that software systems are inherently easy to change. While boilerplate language about “maintainability” is often included, it rarely reflects a serious understanding of what true adaptability requires.
Misunderstanding Software Complexity
Many people who don’t write software see fragile code as an exception rather than the norm—it’s “just code,” and modern technology appears endlessly flexible. But software systems, like any complex creation, require disciplined craftsmanship to remain adaptable.
Short-Term Focus
Funding for government systems often targets a specific set of urgent policy requirements and political priorities, with little consideration for how those requirements might evolve. Legacy architectures and tunnel vision during implementation cause systems to grow rigid quickly, resisting modernization and simplification.
2. Agency Priorities: Neglect of Adaptability from the Start
A lack of focus on adaptable architecture during implementation creates systems that resist change and grow brittle. Key drivers of this rigidity include:
Choosing Speed over Adaptability
Prioritizing feature delivery often sidelines adaptability and quality, driven by the misconception that these slow progress. In fact, embedding adaptability and quality accelerates delivery over time. As the saying goes, “Go slow to go fast.”
Accumulation of Obsolete Components
Agencies struggle to remove outdated regulations, workflows, and integrations, creating operational inefficiencies and unnecessary complexity. As described in Recoding America, these obsolete elements accumulate like “layers of paint,” complicating further improvements.
Resistance to Simplification
Simplifying systems often requires removing unnecessary features or rules, but these efforts are deprioritized due to perceived risks or the inertia of established workflows.
3. Implementation Challenges: Inefficient Change Processes and Technical Debt
The experience of requesting and implementing changes is central to how systems evolve. This experience involves everyone affected by changes to software—from policymakers and end users requesting updates to stakeholders responsible for security and scalability. When modifying systems is slow, complex, and costly, it creates:
Inefficient Change Processes
Slow, cumbersome updates force agencies to choose between expensive fixes or temporary workarounds, compounding technical and design debt. This stifles innovation and responsiveness to user needs.
Internal Frustration
IT teams, developers, and program managers face burdensome processes for even minor updates, leading to burnout and reluctance to make changes.
Neglecting Technical Debt
Without disciplined development practices, systems become brittle and expensive to maintain. Clean, option-enabling code is essential for long-term adaptability but is often deprioritized during implementation.
The High Price of Inflexibility in Government IT
Inflexibility in government IT systems has far-reaching consequences. From development teams navigating rigid requirements to public users dealing with outdated workflows, this lack of adaptability stifles innovation and hampers progress. Below are some common challenges inflexibility creates for various stakeholders:
Accumulating Technical Debt
When systems are difficult to change, agencies rely on temporary patches and incremental workarounds to meet new demands. Over time, these patches create technical debt that consumes resources and limits innovation.
Impact on Stakeholders:
- Technology Leaders: IT teams spend most of their resources maintaining instead of modernizing.
- Agency Leaders: Budgets balloon as technical debt drives up costs.
- Procurement Officials: Replacing debt-ridden systems becomes a costly, time-consuming challenge.
Data Silos and Fragmentation
Rigid systems often lack interoperability, preventing data from being shared effectively across agencies and departments.
Impact on Stakeholders:
- Data Teams: Fragmented systems limit accurate, timely insights.
- Policy Makers: Disconnected data hinders measuring policy effectiveness.
- Agency Leaders: Inaccessible data leads to inefficiencies and poor decision-making.
Slow Response to Evolving Needs
When systems resist change, agencies struggle to implement new policies, update workflows, or adopt emerging technologies.
Impact on Stakeholders:
- Policy Makers: Delays in policy implementation lead to compliance risks and public dissatisfaction.
- Technology Leaders: IT teams face higher costs and operational disruption when updating systems.
- Agency Leaders: Inflexibility erodes public trust in government responsiveness.
Escalating Costs
As systems become harder to change, the cost of maintenance, updates, and workarounds rises exponentially.
Impact on Stakeholders:
- Budget Officers: Rising costs strain resources, leaving less for innovation.
- Agency Leaders: Public scrutiny increases as inefficiencies become more apparent.
- Technology Leaders: High maintenance costs prevent investment in modernization.
User Frustration
Software that is hard to change and modernize frustrates users by locking them into obsolete workflows and policies while failing to adopt modern usability features.
Impact on Stakeholders:
- Policy Makers: Inflexible systems delay support for new policies, pushing users into cumbersome workarounds.
- Internal Users: Obsolete workflows force employees to navigate unnecessary steps and inefficiencies.
- Public Users: Stagnant designs reduce efficiency and frustrate users accustomed to more streamlined tools elsewhere.
Understanding and addressing these challenges is crucial for building systems that truly serve their purpose.
The Solution: Prioritizing Adaptability and Change
To address these pain points, agencies must prioritize adaptability and the principles that enable it. This begins with improving the systems themselves but also requires rethinking the experience of change: how requests are made, how they’re implemented, and how systems are architected to evolve while shedding outdated complexity. It’s equally important to identify IT vendors who specialize in addressing evolving policy needs, improving workflows, and reducing inefficiencies.
Best Practices for Government IT Procurement
To ensure that procurement supports agency operations improves efficiency, and enhances service delivery—all while minimizing risks such as cost overruns, delays, or technical inefficiencies—consider vendors and approaches that offer:
Option-Enabling Architectures
Design systems with interchangeable components that can be updated or replaced independently and with minimal risk, preventing the accumulation of unnecessary features and rules.
Simplify by Design
Regularly audit systems for obsolete rules, technologies, and workflows, removing outdated “layers of paint” to reduce complexity and free resources for innovation.
Scenario-Driven Development
Build systems around real-world use cases, delivered in order of likelihood or priority. Use these scenarios to identify where flexibility is needed most to optimize costs.
Automation
Automate testing, deployment, and integration to streamline the change process and reduce error rates.
Adapting Government Software to Policy Changes
Wrap policy logic with “toggles” to make them easy to enable or disable. Automate traceability to identify and remove obsolete policy code with clean-up tools.
These practices make software soft again, enabling agencies to treat the experience of requesting and implementing changes as the critical user experience it truly is.
Conclusion
In government IT, the ultimate measure of success isn’t just how well a system serves users today—it’s how easily that system can evolve to meet tomorrow’s needs. Yet, many agencies remain tethered to systems that resist both growth and simplification, creating cascading inefficiencies and costs.
The challenge isn’t merely about adding new features or capabilities; it’s about creating systems that can shed outdated rules, processes, and technologies with minimal friction. By prioritizing adaptability, simplifying the meta-experience of change, and designing for long-term flexibility, agencies can overcome the “layers of paint” that hold them back and build systems that truly serve their mission.
The time to act is now: Let’s recode government systems for adaptability. Ready to prioritize adaptability and transform your systems? Contact Flexion today to discover how we can help you achieve lasting impact!
For the past eight years, Doug Knesek has supported Flexion as a software development and delivery leader. Over the past thirty years, he has worn nearly all technical and project management hats in the custom applications development domain. Over the last decade, Doug has used his experience to apply the concepts of agility and self-organization to organizational design and evolution.
