Let’s imagine you need to develop a mobile app. You may already know that this task requires several specialists, but how much effort do they need to put to get the project done? Besides, if a developer puts in a lot more hours for the task than are eventually spent, it may give the impression that this specialist is not an expert because the estimate needs to be revised. On the other hand if the developer doesn’t put in the projected time, they put your project release at risk.
As a rule, estimation is in hours or story points. If the first one is something physical, something you can make a mistake about, story points are about something more abstract.
Typically, software development teams give estimates in time format: hours, days, weeks, and months. Such time estimates are based primarily on personal experience, assumption, or intuition. In such a case, developers look at a task and decide how long it would have taken them. As a result, they are rarely accurate because many factors can affect the timing of the work.
That is why many teams working on Agile methodology use story points, and developers from IntelliSoft are no exception. Let’s look into two approaches.
Table of Contents
So, two main approaches exist to estimate the time you need to create a mobile app product.
What Is Agile Time Estimation?
The use of time as a measuring tool is the most common approach. After all, most things, including working hours, important events, and investment portfolios, adhere to a regular schedule. As a result, most product managers, product owners, and key stakeholders are interested in learning how much work a team member can accomplish in a given time interval.
In this manner, management can estimate when to finish a particular work and when the entire project is over. Managers can also hold other team members accountable for their work by using this strategy, which makes it simple to recognize when goals do not meet the allotted time.
Is Time Estimation Perfect?
Since Agile estimation is a group effort, time estimation may be the simplest. Most team members will need help grasping the meaning or use of this standardized corporate measurement. Because of this, groups can more accurately estimate the length of time it will take them to complete an assignment.
Time estimates can be a massive help for many groups and projects but can also be a huge hindrance. At the beginning, there are some jobs for which a timely determination is impossible. This fact may be especially true of highly complicated jobs that are not fully specified. Large tasks, for which time might be readily under- or over-estimated, may provide similar challenges.
Time is a common source of stress. If estimations are slightly off, team members and management can be under unneeded stress. Frequently, this tension can result in grave errors or wasted opportunities to produce something extraordinary. Without proper time management, it might hinder performance.
Hourly estimates are straightforward. However, there are a few factors to think about:
- How much time does the developer spend on the project?
- Does the programmer take part in gatherings unrelated to the project?
- When do sprints occur, and what kind of events are there?
- In how many seconds can we expect to finish the sprint?
- Should we plan for some wiggle room to accommodate last-minute changes to the production?
- Are any vacation time or days off scheduled for the next sprint?
Estimates for narrative points are comparable; the same factors impact the team’s capacity. The first step for developers is to estimate how much work they can complete in a sprint, for example, one more extensive assignment and a few smaller ones. Doing fewer tasks in a sprint allows you to feel comfortable adding a few more from the backlog, which is an excellent exercise for learning your time capacity.
The team often better understands the project and can accurately estimate it after two or three sprints. Then, it is highly likely that they will execute their sprint plan in full.
What Are Story Points?
What is the story point in Scrum or Agile? A story point is a unit of measure expressing an estimate of the total effort required to implement a particular functionality fully. In other words, it is a kind of relative complexity. Story points are part of the user story pointing.
Teams assign a score in story points based on the complexity of the work, the amount of work, the risk, or the uncertainty. Typically, these values are assigned to break down the work into smaller pieces, eliminating uncertainty.
Over time, it helps teams understand what they can accomplish in a given period and helps them plan more accurately for the following pieces of work.
It may seem utterly illogical to you, but this abstraction is useful: it pushes the team to make tough decisions about the complexity of the work.
How to Calculate Story Points
Sprint is a repeatable fixed time interval during which programmers create a specific functionality. At the beginning of development, the team determines how long this time interval is by agreement between the team and the customer. For instance, this period can be two weeks or a month.
As a rule, tasks are estimated at the beginning of the sprint to plan the possible amount of completed work by the end, when managers present the finished work to the customer.
Using story points, we assign a quantitative value to each item (task). These quantitative scores themselves are not necessary. What is important is how the scores of the different elements relate. A story given a value of 2 should be twice as big as a story with a value of 1 and correspond to two-thirds of a story with a value of 3.
Instead of one, two, and three, the team could use 100. It is the ratio, not the numbers per se, that matters. Because story points express efforts to accomplish a story, the team must evaluate anything that will affect those efforts, like:
- The amount of work to do
- The complexity of the work
- The risks or uncertainty in getting the job done
When measuring the work with story points, evaluate each of these factors.
The more work that needs to be done, the greater the notional effort figure should be. Consider the development of two web pages. One should have only one field and ask for a name. The second page should have 100 text fields.
The second page should obtain more story points. Maybe not 100 times more, although it has 100 times more fields. After all, there are economies of scale, so in reality, you might only spend 2, 3, or 10 times as much effort on the second page as on the first one.
Second, you need to include risks or uncertainties in work. For example, the team may need to estimate a backlog element the stakeholder can’t say anything about. A similar situation: it is necessary to put a markup on complexity when implementing a feature requires rewriting old unreliable code without autotests.
The uncertainty, as such, reflects in the sequence of numbers for story points, which resembles the Fibonacci sequence: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233.
Finally, consider complexity. Let’s return to our page with 100 fields without interactions between them.
Now imagine another page with 100 fields. Some of them are fields with dates and, respectively, calendar widgets. In the other part, you can enter only a limited number of characters; for example, phone numbers.
There are also fields where the checksum is checked (for example, with bank card numbers). In addition, there are interactions between domains. The page should produce a field with a three-digit CVV code for the Visa card and the American Express card, a four-digit CVV code.
Although there are still 100 fields on the screen, the development will be more complicated and take longer.
Why Are Story Points Used in Agile?
For one, story points aren’t for an Agile estimate. For instance, the Scrum story points guide specifies that throughout the sprint, it is the exclusive responsibility of the development team to determine how best to implement the value increment resulting from the prioritized stories. They are free to decide how they want to go about it.
What’s the deal with all these Agile story points? Because programmers can use them with minimal effort on your part, with story points, developers can quickly gauge the complexity of impending tasks and plan accordingly.
The team’s confidence in the estimate decreases proportionately with the variable’s value. Nevertheless, despite the simple implementation of the procedure, it does not produce reliable results.
When Story Points Can Go Wrong
- Talking about days
Keep in mind relative effort, complexity, and uncertainty.
- Spending an excessive amount of time debating the nuances
Don’t get trapped in the weeds. If there are some “3s” and a “5”, then you shouldn’t spend a great deal of time debating whether or not you should introduce a “4.”
- Using the team’s points as leverage against you
Keep in mind that the only specialists who should be considering the points are the product team.
What Are Man Hours?
A man-hour, also called a person-hour, is the job the average worker can do in an hour. With this approach, it is possible to figure out how many hours of continuous work are needed to finish a job. For example, it might take 80 man-hours to do research and write a technical paper, but only ten man-hours to make a family meal from scratch.
Man-hours don’t include the breaks people usually need at work, such as rest, eating, and care for other needs. They only count real work. Managers estimate how long a task will take by adding the hours a person works and the time they take for breaks. So, a tech paper might take 20 hours of work, but it’s unlikely to be ready in twenty hours. Its progress will be slowed by work for other classes, eating, sleeping, and other things people need to do.
How to Calculate Man Hours
What we call “man-hours” is the sum of humans’ time during a given time frame. Understanding how to calculate man-hours is essential for everyone, as it is the basis for measuring the effectiveness of health and safety programs.
Employees’ time spent on a project is significant in making a competitive bid and receiving payment. Accurate time tracking and reporting are critical to the success of any contracting organization because labor costs so much.
Man hours formula = Total hours work a day x Total number of workers x Total number of days worked over the specific period
Pros & Cons of Story Points
Let’s look at some reasons to use story points in project estimation:
- You can avoid inaccurate estimates in time intervals.
- You can better account for overhead costs instead of time estimates: communications between team members and the customer, planning, and unforeseen situations.
- Each team will be evaluated on a different scale, meaning their rate (measured in points) will differ.
- By defining a scale for assigning each story point, you can quickly allocate points without much controversy.
- Precise time evaluation
The app development team needs time to compute story points’ velocity, but they can determine the launch date once they do. The team knows how many story points they can release in a sprint by tracking velocity. Changes in team members, requirements, or feature number/complexity rarely generate re-estimation issues.
The developer of your project may sometimes leave and be replaced. They could get sick, decide to take parental leave or a sabbatical, or just quit. Maybe they won’t be good enough for the job.
When they are replaced, the new developer might work at a different pace, so it is necessary to recalculate the number of hours it will take to make. Story points make this less of a problem. Story points are helpful for all developers at a company.
- Easy to re-estimate development time
Teams continually monitor their velocity, which is initially highly varied. A team can release five-story point features one week and twenty-story point features the next. Nevertheless, this is merely the beginning. As the project advances, the velocity graph will become more uniform.
- Excellent for monitoring team performance
Teams working on the same or similar projects or activities at various periods can simply compare their respective rates of progress using velocity. Are they better now, and if so, how much? Which group or programmer has been struggling and may need additional training? Can you describe the progression of difficulty? Perhaps a different group would fare better.
- Reusable for future projects
It is not unheard of for a corporation to specialize in a specific niche (or numerous niches) and construct more than one product with a set of features that are very similar to one another. After finishing even a single project estimated in narrative points, developers can refer to this estimate when working on subsequent projects. This step will cut down on the amount of time needed for story point estimation.
- Enhances teamwork
Estimating the difficulty of a task using narrative points provides an opportunity for developers working on similar projects to collaborate, which usually does not occur. Working together in such a way offers an excellent opportunity to talk about previous experiences and encourage one another.
- More complex to budget
Programmers invest effort in a project beyond just coding (or making designs and testing). Finding information, having conversations (both internally and with the client), making adjustments, etc., all take time. Points for a story do not account for the time spent estimating those points, even when that time is spent on the project.
Although creating a budget using story points is feasible, the time-and-money method is typically more efficient.
- More than one developer needed
The story points model is appealing because it is based on facts and can be used to predict the future. However, for that to be true, more than one developer must do the story point estimation. Story points don’t have as many benefits for small companies with only one team or companies with only one expert in a field, like a single designer or iOS developer. Small businesses like these usually use worker hours as a way to estimate.
- Considerable backlog required
Your team will need to invest a lot of time to maximize the potential of story points. The first two to three sprints of a project with features the team hasn’t worked on before (or hasn’t worked on full-time) may be challenging to forecast in terms of performance. Given the wealth of statistical data, it is true that the more backlog items your teams have, the more accurate their estimations can be. However, the system for story points is not yet fully operational.
- Estimated velocity per team
This parameter indicates that you will need to calculate the velocity for each combination of developers on a project-by-project basis if teams switch between different projects. As a result, an accurate estimate for one team may not be valid for another team, and the addition or removal of a single member of a team is enough to render previous incorrect estimates.
How to Convert Story Points to Hours
Customers may request an Agile story points mapping into hours conversion from an estimating team that uses story points. Still, some people won’t understand what “story points” are.
The time and energy invested in completing tasks is a significant factor in complexity-based estimation. Yet, the time invested does not necessarily reflect the amount of work. Hours deal with doubt in a more nebulous way than plot points. Therefore, it’s impossible to give a precise answer to a client who asks how many hours a story point equates.
Developers can use the Fibonacci sequence to allocate story points in a way that will, to some extent, accommodate for uncertainty in development times; however, this method only allows for a direct conversion.
Let’s say it takes two hours to finish a base story with one story point.
In the best case, it might take 26 hours to write a 13-story point story if nothing goes wrong or gets in the way. For example, if the API works well from one endpoint to the next. If it doesn’t, the story could take 30 to 50 hours, depending on how many things don’t match up. If the developer hasn’t worked with the API in question yet, no one can tell in advance how it will go.
Mistakes to Avoid
Unfortunately, story points are often misused. They can go wrong when used to estimate people, detail timelines and resources, and when mistaken for a productivity measure.
Instead, teams need to use them to understand the amount/complexity of work in each task and prioritize them. The parts rated as more strenuous should be in work first so that they are ready before the sprint’s end, and the easier ones postponed. In particular, be aware of the following pitfalls:
- Including story points in bugs
- Revising problem estimates during the sprint by converting story points into hours/stakeholder value
- Being frightened of the leader or the expert
- Reiterating a focus on open questions
- Thinking, “It’s worth x points if I do it and y points if I don’t”
To avoid these mistakes, check outstaffing companies with vast experience in working with both man hours and story sizing.
H2: Pros & Cons of Man Hours
- Clients frequently pay for hours
This model requires very little explanation. Estimations based on complexity can sometimes be challenging to understand for customers. In addition, if the customer places a higher priority on the project’s cost than it does the launch date (typically the case), story points won’t be of any use to them.
- Man-hour is a familiar model
Estimating a worker’s hours is not foreign to developers or their customers. It takes some time to be innovative. Many people subscribe to the philosophy that “if it ain’t broke, don’t change it.” Moving to another approach is possible if the method provides accurate estimates.
- One developer can do an hours-based estimation
Story points are primarily ineffective for small teams and freelancers because they require various points of view. Without a reference, estimating using story points is a burdensome endeavor. On the other hand, hours provide the developer working on the project with a method for self-estimating with reasonable precision.
- Hard to estimate huge tasks in hours
It’s not hard for developers with experience to provide an estimate for a little assignment. However, the greater the work, the greater the number of internal and external factors that can hinder progress. Hours-based estimates are less precise because they lack the leeway of story points.
- Being solely responsible for the assessment
On the one hand, calculating your own time needs may be more straightforward because you have to account for yourself. On the other hand, it’s a major setback if you don’t meet your projections.
- Almost no flexibility
Time estimation based on hours is highly rigorous. The developer determines hourly assessment. If a product development team member leaves in the middle of the project, the team will need to recalculate each affected user story still in progress or slated for future sprints. Depending on the level of the project and the gap in expertise between the original and replacement developer, it might be a substantial undertaking.
- A developer’s estimate is less precise than a team’s
Some programmers have the terrible habit of overestimating their abilities and setting deadlines that they find challenging. This step not only throws a wrench into the development process (which may result in additional costs for the team if there are penalties) but also leads to stress and exhaustion for the developers.
Which One Is Better: Story Point vs. Man Hours
Several factors may help us to define the winner in the story points vs hours battle.
Excellent for high-level estimation
Story Points are an indispensable method for the first estimation. Whereas it is easier to estimate a User Story in hours with a transparent data model and precise requirements, Story Points help you comprehend the job scope, at least at a high level.
Story Points are a helpful estimation tool since they allow you to take into account a wide range of variables, including those resulting from interactions with external services. As story point estimation allows the team to consider any uncertainty linked to the work item estimated, it is the most sensible option to take if you want to integrate an API but don’t have access to the API documentation.
Velocity enhances Story Points estimation. Velocity is a sophisticated capacity planning approach that shows how much product backlog effort a software development team can handle in a sprint. Team velocity is the goal. Post-sprint retrospectives focus on increasing velocity. The team’s velocity determines its speed and efficiency.
However, velocity is a relative value that can change throughout the project. The next advantage is that you will not have to re-estimate your project if the velocity changes, whereas estimating in man-hours would necessitate a recalculation.
No correlation with the skills/experience of the estimator
As previously indicated, a specialist who estimates a task is not always responsible for its execution. Senior and junior developers require different intervals to finish the same task. The best way to avoid this is to have the same developer estimate and implement a project.
Story Points, a team-wide measurement, solve this issue. The estimate is independent of the team member. Differently skilled developers can discuss it and reach a consensus. The staff can understand story size and complexity.
The ability to re-plan product release dates without having to re-estimate all jobs is another advantage provided by Story Points. This benefit is beneficial in situations where team members need to be replaced.
It is common practice for one individual to provide an estimate for a job while others carry out the actual work. In this particular scenario, Story Points are essential.
- Innovation Roadmap: When to Use a Proof of Concept or Prototype
- Assembling Your Dream Design Team: A Comprehensive Guide
- 11 Software Developer Soft Skills Every Programmer Needs to Succeed
- Advantages of Using Kubernetes Containers in Your Product
- What’s a Proof of Concept? The Complete Beginner’s Guide