Search for a command to run...
I am a Journalist-turned-Software Engineer. I love coding and the associated grind of learning every day. A firm believer in social learning, I owe my dev career to all the tech content creators I have learned from. This is my contribution back to the community.
No comments yet. Be the first to comment.
While there are voluminous books on HTTP, I have done my best to condense the important parts that every developer must understand about HTTP in one article. Let's look at the HTTP version used at some of the top websites in the world. Open Chrome ...
📖 Introduction In modern AI applications, communication between clients and tools isn’t always as simple as calling an API. The Model Context Protocol (MCP) provides a standardized way for clients to exchange information, invoke tools, and maintain ...
If you’re curious about how to build an intelligent agent using Model Context Protocol (MCP), you’re in the right place. In this post, I’ll walk you through how to: Create an MCP Server using FastMCP Expose a tool that calculates BMI Build a Clien...
In our previous tutorial, we built a restaurant customer support chatbot using OpenAI's Agents SDK. In this follow-up, we’ll explore guardrails—a critical feature that enhances AI chatbot safety and reliability. What Are Guardrails in AI Agents? Guar...
Video https://www.youtube.com/watch?v=UPBMkFSJdBI The Problem at Hand Uber's data platform processes approximately 1.2 million interactive queries monthly, with 36% of these coming from the operations organization. This group—comprising engineers...
Video https://www.youtube.com/watch?v=FgRGwnpd2HY Google's recent white paper on "Agents" has created quite a buzz. The paper explores the concept of AI agents and delves into their architecture and potential. Let's break down what this white paper...
I am Zahiruddin Tavargere (Zahere). A social-learner, here to learn, share and grow with the tech community.
74 posts
I am Zahiruddin Tavargere (Zahere). A firm believer in social learning, I owe my dev career to all the tech content creators I have learned from - this is my contribution back to the community.
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 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.
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.
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.
Ignoring those accumulated shortcuts and suboptimal solutions during story point estimation can lead to inaccurate time predictions and jeopardize project timelines.
Tasks that seem simple on the surface can become much more complex due to dependencies on outdated or poorly structured code.
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.
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.
Urgent bug fixes or critical feature updates may get pushed aside due to unforeseen complications arising from the accumulation of technical debt.
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.
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.
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.
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:
