TL;DR: Everyone agrees on the 20% rule. Almost everyone abandons it. Here's why that keeps happening and a more honest approach that accounts for the chaos most teams are actually operating in.
If you know someone managing a technology backlog and losing the battle against urgent work, feel free to pass this on. The quarterly framing near the end is practical and worth a conversation. Thank you :)
There’s this piece of wisdom that everyone in technology management knows: dedicate 20% of your available time to maintenance. That’s one day a week, or one week out of every five, spent fixing underlying issues (what engineers call technical debt) instead of only building new features.
Think of it like pausing construction on a house to repair the leaky pipes and reinforce the foundation.
Everyone agrees this is a smart practice. We nod our heads in planning meetings, acknowledge its long-term importance, and promise to focus on it.
And yet? It’s a rule that almost everyone abandons.
If we all understand that a strong foundation is crucial for future speed and stability, why do we constantly ignore our own advice? It’s not intentional.
The Pattern We All Recognise
I’ve seen this same pattern across multiple organisations. The intention is always good. Someone raises a painful problem, like “We need to finally speed up that overnight data transfer. It used to take two hours, but now it’s taking six”. The task gets added to the list.
Then, the real world interrupts.
A critical security flaw is announced that requires immediate patching. The audit team flags a non-compliant process that must be fixed by the end of the month. A key vendor announces their platform is being retired, forcing a mandatory, unplanned upgrade project.
None of these interruptions were anticipated. All of them demand attention now. And the maintenance task, well that takes a back seat. On hold, or pushed back a sprint.
When this failure of prioritisation is discussed, there’s a common and fair criticism: “The problem isn’t the rule, it’s the lack of discipline”. Leaders argue that critical maintenance should be treated as a protected, non-negotiable block of time. But then don’t protect it.
I agree. We need discipline; it’s essential. But here’s the thing: the issue isn’t just a lack of focus or prioritisation. The problem is that Mandatory Risk events (vendor changes, regulatory deadlines, security crises) are too large and too unpredictable to fit neatly into a weekly schedule. No amount of discipline will stop a government-mandated change, and these major external shocks keep chipping away at the assumed 20% capacity. Even in teams that prioritise protecting this work.
Why Small Fixes Aren’t Enough
The 20% rule assumes that the time you have available is stable. It assumes that major architectural problems are like a small, steady leak that you can fix with regular, small chunks of time.
This brings up another valid point: “Why not just fix things as we build?” Many excellent engineering teams operate by the “Boy Scout Rule”, meaning developers are expected to leave the code cleaner than they found it. But sometimes this isn’t possible on large programs with strict timelines and monitored budgets. Your code may be fine, but you find adjacent code that isn't, and you don't have time to fix it.
That’s why a continuous maintenance approach is absolutely vital for preventing new debt from accumulating. Today, most believe it should be a baseline expectation for upkeeping quality.
But here’s what I’ve observed, sometimes these small improvements just aren’t enough for dealing with years of accumulated, systemic debt. You can’t fix years of architectural problems with small improvements. Sometimes you need to throw up a larger project and initiative to deal with it. Decommissioning that expensive legacy system, rebuilding the broken data architecture, or stabilising that fragile reporting process? Those need real, dedicated time.
These are structural problems. When the intended 20% time is eroded by crises down to 5%, that remaining time is too small and too fragmented to address these major, complex repairs effectively. By constantly deferring the big fix, you don't avoid the work. You just guarantee it happens later, under worse conditions, at a higher cost.
Building a System That Protects the Important Work
The 20% rule fails in mature enterprises because it frames essential maintenance as optional. And optional work always loses to urgent work.
To build a system that actually works, we need to acknowledge the three realities of our workload:
Mandatory Risk: Urgent issues tied to security, compliance, and vendor deadlines. These are budgeted as non-negotiable overhead.
Continuous Maintenance: Small, localised clean-up activities built directly into every task.
Strategic Improvements: The large, high-value projects that reduce future costs or unlock future speed.
So how do we protect this Strategic Improvement work? One approach that I’ve seen work is building a system that makes trade-offs visible and creates clear accountability:
Focus on Business Impact and Risk: Stop calling the work “technical debt”. Frame these issues in business terms: the process costing the company $500 per day in manual work, the system creating a severe future liability.
Think in Quarters, Not Weeks: Instead of the failing weekly “20% allocation”, commit to “One Major Improvement Project per Quarter”. This creates a protected, sustained block of time large enough to achieve a deep, impactful fix.
Make the Work Visible and Valuable: Treating these improvements as dedicated quarterly projects (not just “time we’ll try to find”) does two things that are often underestimated:
Accountability: If a critical new feature request competes with this scheduled maintenance project, leadership is forced to make a public, clear trade-off: “We are cancelling the approved efficiency project to chase this new revenue”. This ends the silent erosion of maintenance time and forces accountability onto the business decision-makers.
Career Growth: The project gives teams a highly visible, measurable achievement to celebrate (for example, “Led the Q3 Efficiency Initiative, reducing manual effort by 15%”), ensuring this critical work finally gets the recognition it deserves.
The Bottom Line
The 20% rule works brilliantly on paper. It assumes a stable, predictable environment where nothing urgent ever interrupts your plans.
But that’s not the world most of us operate in. If you’re managing mature systems dealing with vendor changes, compliance deadlines, and constant urgent demands, you need a strategy built for reality. One that anticipates the chaos, forces trade-offs into the open, and truly protects the work that keeps your systems running well over time.
Here’s what changes when you shift to this model: your team stops feeling guilty about “never finding time” for the important work. Leadership stops being surprised when technical issues become crises. And most importantly, you start building systems that actually get faster and more reliable over time, rather than slower and more fragile.
The work still gets prioritised against other demands. Some quarters, business needs will win out. But at least now those decisions are visible, deliberate, and made by the people who should be making them. And when you do protect that quarterly improvement project? You get to celebrate real, measurable progress that makes everyone’s job easier.
That’s not just better accountability. It’s a system that actually works. For us all.
~ Pete G


