
The deadline is fixed. The application has to be ready. To meet the date, its technical structure is neglected. What does that mean for the work that follows?
A fixed deadline and its consequences
Consider a hypothetical example from public transport: an application for analysing service performance data has to be ready by a set date. Shortly beforehand, some functions are still missing. To meet the deadline, the team adds special cases directly to the existing code. Clear separation of responsibilities within the code and the planned rework receive too little attention.
The application is finished on time. What remains is technical debt: weaknesses in the implementation that can make later changes more difficult.
When new functions build on provisional solutions
This may become apparent with the next feature. Adding a new analysis is cumbersome because it has to build on those special cases. Rather than reworking the affected function, the team works around it. For example, an incorrect result is corrected in a later processing step because fixing the underlying cause seems too time-consuming at that point.
The logic is now spread across more places. Anyone making a later change has to understand these corrections and dependencies too. If the original weakness remains, further extensions may lead to additional workarounds and new technical debt.
That extra effort leaves less time for new functions. Fixing the original weaknesses can also become harder as more code comes to depend on them.
Planning for what comes next
For me, a decision made under deadline pressure therefore needs to include a plan for what happens afterwards:
- Which compromises are we making?
- What consequences do we expect for further development?
- And when will we review whether the affected parts need reworking?
A fixed deadline may call for this kind of trade-off. The technical consequences need to remain visible and be considered in the next round of planning. Especially before more functions are built on a provisional solution, reworking it should be part of the discussion.
How do you make sure that technical debt created under deadline pressure gets back on the agenda after launch?
Sources and further reading
- Martin Fowler: Technical Debt (2019). Explains how weaknesses in internal structure create extra effort when software is changed.
- Ramač et al.: Prevalence, Common Causes and Effects of Technical Debt: Results from a Family of Surveys with the IT Industry (2021). The study collected 653 valid responses from six countries. Time pressure or deadlines were the most frequently cited cause; frequently cited effects included delivery delays, low maintainability and rework. These are survey findings, not evidence that this outcome is inevitable.