Software estimation is notoriously difficult. While stakeholders want accurate estimates of time and cost, product managers, designers, and developers often struggle to accurately make these estimations—as evidenced by the prevalence of cost overruns and extended deadlines. The good news is that there are a few strategies that you can use to improve estimates over time.
Let’s take a look at five ways to improve the accuracy of your estimates and some tips to implement these strategies into your team’s workflow.Software estimation is notoriously difficult but there are a few strategies that you can use to improve estimates over time. Click To Tweet
#1. Start with Defining Project Goals
Estimates are designed to predict the time and cost of a project, but oftentimes, businesses need to determine if a project is economically feasible before developing detailed plans. By identifying project-level goals, product teams can typically provide ballpark estimates to help stakeholders determine if a project should move forward.
Some key questions to ask include:
- How will users use the software (e.g., web, mobile, or both)?
- How many users will the software serve?
- What should the software do on a high level?
The idea is to come up with ballpark cost, and time estimates to determine if a project is feasible. If the goals are too ambitious, stakeholders may want to pare down the scope (e.g., target a single platform or just a couple workflows) in order for the project to be feasible. Starting with a smaller, more realistic scope can help improve the chances of success.
#2. Consider Behavior-Driven Development
Project-level goals are necessary for ballpark estimates, but technical requirements are necessary to fine-tune these estimates.
Behavior-driven development, or BDD, provides a helpful framework for defining functional scope. Stakeholders, developers, and test engineers meet to come up with business use cases—called scenarios—that are written in a human-friendly language called Gherkin. The goal is to ensure that everyone is on the same page before any code is written.
The magic of BDD happens when Gherkin scenarios are converted into executable specifications that developers must pass when writing the actual code. The test-driven development process results in code that meets agreed-upon business use cases, as well as living documentation in the form of Gherkin scenarios.
#3. Don’t Forget Non-Functional Requirements
Non-functional scope can have a significant impact on the time and cost of some projects. For example, the functional scope of bank software may be relatively straightforward, but non-functional security requirements may be extremely time-consuming and complex. You may need to bring in dedicated cryptography experts and undergo time-consuming audits.
There are many such non-functional requirements:
When scoping out software projects, you should account for these kinds of non-functional requirements. While not every project requires bank-level security, most projects do have scaling requirements that need some level of DevOps engineering expertise. And maintainability can become a concern for projects expected to grow over time.
#4. Choose the Right Strategy for Each Project
There are many different ways to estimate software projects. While Agile story points may be right for a large enterprise application, it might be overkill for a three-person development team working on a minimum viable product (MVP). The best estimation strategies provide the right level of insights without spending too much time on estimation itself.
In some projects, estimates may not even be necessary. Projects that don’t have a hard deadline, such as a conference or other launch event, may be better managed with priorities. Prioritizing features rather than introducing hard deadlines can ease the pressure on the team while balancing development velocity with code quality.
Larger projects and teams often benefit from Agile story points. Rather than estimating a feature in hours, story points involve estimating the difficulty of a task in abstract terms. The idea is that developers are better able to estimate difficulty than time while product managers can still correlate the two to come up with more accurate time estimates.
#5. Constantly Adjust and Improve Estimates
Estimation typically begins with a wide range that narrows over time as the concept materializes, engineers become more accurate and uncertainty decreases. For example, a product manager might estimate that an initial project will take about six months to complete at the onset, but over time, an estimated completion date can be narrowed down to the week.
Story points enable development teams to improve estimates over time. Using burn down charts, product managers can compare story points to time in order to assess the velocity of development and estimate whether a goal is achievable. Atlassian and other tools simplify the process of visualizing and computing these estimates while keeping everything organized.
Need Help with Estimation?
Estimation is a tricky process that requires business and technical teams to agree on a common scope. In many cases, internal teams could benefit from outside help when creating a clear-cut roadmap that everyone can agree upon.
Our Custom Development Roadmap service is designed to help you start with a clear-cut roadmap for a finish that’s on-time, on-budget and has all of the features and functionality that you want. With over a decade of experience creating business-minded applications, we can help explore different options and select the soundest approach to achieve your goals.
We have a simple three-step process:
- Discovery: We identify how you work, what makes your business tick, and what functions your software needs to perform.
- Mapping: We create a detailed summary of the initial discussions, the needs you’ve expressed and step by step technical instructions to build the software.
- Execution: You can work with our senior engineers or provide your own developers with a clear plan to create a high-quality product.
The Bottom Line
Estimation is an important part of the software development process. While the process can be a challenge, there are several strategies that you can use to improve estimates and deliver more meaningful data points to stakeholders.