Design and Delivery: Two Sides of the Same Coin
One of the points of agile development is to seek input from customers throughout the development process, including early stages. But if a development team isn’t allowed, without authorization from some outside body, to change requirements or specifications in response to what they discover, their ability to innovate is sharply inhibited. —Nicole Forsgren et al.,
Accelerate: The Science of Lean Software and DevOps
Good design is not a one-and-done activity—it is an iterative process of shaping, testing, and refining ideas in response to how real users engage with them. The best designs emerge not from isolated studios or static documentation, but from rapid cycles of delivery, feedback, and improvement.
Unfortunately, this is where many government digital services fall short. The issue is not simply a lack of design talent or access to modern design methods. Rather, it is the friction in delivering design outputs to real users, and the difficulty of iterating quickly once those outputs are in production.
Why Iteration Matters
When users cannot interact with design artifacts, or when changes take weeks or months to deploy, the quality of the resulting services inevitably suffers. Designers are left guessing about user needs, and by the time changes are implemented, the context may have shifted entirely.
The lifeblood of good user experience is frequent deployments. Continuous deployment (the CD in CI/CD) is not just an industry trend, it is literally how improvements and enhancements get into the hands of users. If the time between software deployments is measured in months (or even years for some government organizations) no amount of user research or data analytics can save you. You can’t meaningfully help users unless you can get them enhancements quickly, reliably, and securely.
As service design scholar Lara Penin puts it in her book An Introduction to Service Design: Designing the Invisible:
Designers of interactions not only need to spend a lot of time trying to anticipate people’s reactions but also – and foremost – they need to get their interaction ideas out there and test them with users in context throughout the development process.
This is the heart of good design: short, frequent feedback loops that allow teams to adapt based on what they learn. Understanding the connection between deployment frequency and user experience is critical to successful digital solutions.
The Barriers Governments Face
Government agencies face unique challenges in achieving this kind of rapid iteration. Compliance requirements like Authority to Operate (ATO) add delays before new features can go live. Legacy systems make deployments risky and expensive. And many teams lack mature DevOps practices that make delivery seamless and low-risk.
Poor DevOps practices are often the unseen culprit in poor digital service designAs a result, even well-researched, well-crafted designs often stall before they can make a meaningful impact.
Making Iteration Easier
Improving government services isn’t just about bringing in skilled designers or training staff in human-centered design, though that’s important as well. Those investments will only go so far if agencies cannot act quickly on what they learn from users. The key is reducing the cost, in time, money, and risk, of delivering and iterating on design ideas.
Mature DevOps practices make iteration cheap, secure, and fast. Automated testing, continuous delivery pipelines, and modular architectures mean teams can experiment safely, deploy quickly, and revert easily when needed. Frequent deployments aren’t just a nice-to-have—they are how user experience improves in practice.
If we want better digital services for the public, we need to focus not just on designing the right things, but on making it easier for governments to deliver and refine them—over and over again.
