The Context
Picture this.
The product you are working on is a few years old. Through trial and tribulation, your team has been constantly adding new features.
The team has planned to implement an important feature of the product.
The team was feeling really confident, so they started estimating the work they had to do.
They carefully divided the tasks into smaller pieces, thought about how complicated they were, and gave them story points. Everything was perfect.
But as the development started, they realized something scary.
Even though they were thorough in their efforts, the story point estimation appeared to be quite far from reality.
Small shortcuts taken to meet deadlines previously had come back to haunt them.
The estimated work seemed never-ending, weighed down by the burdensome tech debt.
Panic loomed, and the team spiraled into an estimation nightmare, haunted by their own creation.
Been in this situation? Do not worry, you are not alone.
When it comes to estimating the time and effort required for a software development project, one crucial factor often gets overlooked: tech debt.
Tech Debt
Tech debt refers to the cumulative consequences of taking shortcuts or implementing temporary solutions during the development process.
These shortcuts and compromises may help meet immediate deadlines, but they create long-term problems that accumulate over time, hindering progress and slowing down future development.
When tech debt is not accounted
Taking tech debt seriously during story estimation is vital for several reasons.
Failing to account for tech debt can lead to inaccurate estimations.
Ignoring tech debt in estimation leads to underestimating the complexity and potential obstacles, setting unrealistic expectations for project timelines.
Unresolved issues, suboptimal coding practices, and accumulated shortcuts increase the likelihood of bugs, crashes, and performance problems.
Overlooking tech debt in story estimation can have a detrimental impact on team morale.
In fact, a 2021 survey by Coding Sans shows that top-performing teams showed estimation as the number 1 cause of software delivery problems. Unaccounted tech debt plays a big role here.
The factors affecting estimation accuracy
Complexity: The extent to which the number of components and associated component interactions is considered challenging
Scale: The size of the effort
Timelines: The impact of aggressive timelines
Prior estimation experience: The years of experience involved with estimating effort in software development projects
Perceived Project Control: The degree to which the effort timeline can be influenced by developers
Domain knowledge: The degree to which agile team members are familiar with the discipline or field that the application encompasses
Codebase knowledge: The degree to which the agile team members have past experience with existing source code
There appear to be not many research models that incorporate technical debt into an existing effort estimation process involving agile software development projects.
A 2019 whitepaper "Hitting the Bullseye: The Influence of Technical Debt on the Accuracy of Effort Estimation in Agile Projects" by James Ball of the University of Mississippi, talks about how Tech Debt is hardly considered during effort estimation.
The analysis showed TD positively affects AEE. Specifically, as Technical Debt is considered more by the agile team during the effort estimation process, the Accuracy of the Effort Estimate in an Agile Project improves and therefore 100 increases the likelihood for an on-time delivery.
What is the impact of Tech Debt on Story Point estimation?
Hidden Time Bombs
Ignoring those accumulated shortcuts and suboptimal solutions during story point estimation can lead to inaccurate time predictions and jeopardize project timelines.
Impaired Velocity
Tasks that seem simple on the surface can become much more complex due to dependencies on outdated or poorly structured code.
Increased Rework
Ignoring tech debt during estimation can lead to underestimating the effort required to complete a user story. As a result, you may find yourself facing unexpected rework as you encounter roadblocks caused by the tangled web of technical debt.
Unpredictable Dependencies
Tech debt can introduce unexpected dependencies between different user stories. These dependencies can cause delays and bottlenecks as the team struggles to address the underlying issues and integrate new features or changes into the existing codebase.
Challenging Prioritization
Urgent bug fixes or critical feature updates may get pushed aside due to unforeseen complications arising from the accumulation of technical debt.
In what ways can developers account for tech debt during the estimation process?
Awareness and Documentation
Developers should be aware of existing tech debt and document it appropriately. This includes identifying areas of the codebase that require refactoring, known bugs or issues, and any technical limitations that may impact the estimation process.
Task-Level Estimation
When breaking down user stories into smaller tasks, developers should allocate time specifically for addressing tech debt. This could include allocating time for refactoring, code cleanup, bug fixing, or improving existing functionality affected by tech debt.
Communication with Stakeholders
Developers should transparently communicate the presence and impact of tech debt to project stakeholders, such as product owners or managers. This helps set realistic expectations and ensures that the importance of addressing tech debt is understood and prioritized appropriately.
Conclusion
Developers should advocate for regular time allocated to addressing tech debt as part of the development process. By actively tackling tech debt, developers can gradually reduce its impact on future estimations and improve overall project efficiency.
I write about System Design, UX, and Digital Experiences. If you liked my content, do kindly like and share it with your network. And please don't forget to subscribe for more technical content like this.
Sources: