Archive
What is the cost of a bug?
If you have wondered how much a bug cost and how to measure this, today I am going to show some research about this. You must be asking, but why invest in testing if you can just fix your mistake after? What’s the true cost of a software bug? The cost depends on when the bug, or defect, is found during the SDLC (Software Development LifeCycle.)
In 2016, the software failures cost the worldwide economy $1.1 trillion. These failures were found at 363 companies, affected 4.4 billion customers, and caused more than 315 years of time lost. Most of these incidents were avoidable, but the software was simply pushed to production without proper tests.
It’s time to pay attention to how much software errors cost to your company, and start taking steps to recoup those costs.
To illustrate: if a bug is found in the requirements-gathering phase, the cost could be $100. If the product owner doesn’t find that bug until the QA testing phase, then the cost could be $1500. If it’s not found until production, the cost could be $10,000. And if the bug is never found, it could be secretly costing the company money. A 2003 study commissioned by the Department of Commerce’s National Institute of Standards and Technology found that software bugs cost the US economy $59.5 billion annually.
The cost of a bug goes up based on how far down the SDLC (Software Development Life Cycle) the bug is found
Then there’s the domino effect to think about. The software development approach often need to change to accommodate the code fix, which can in turn bump back other code changes. So not only is the bug going to cost more to fix as it moves through a second round of SDLC, but a different code change could be delayed, which adds cost to that code change as well.
Test early, test often. Prevention is better than the cure
To ensure that bugs are fixed at an earlier stage, take advantage of the following security testing practices:
- Get together the team to help identifying issues during the design phase of software development.
- Implement code review stage
- Create an automated regression or smoke tests pack and run them often
In development, you often have less data, use one browser and use the software exactly as intended. Plus you probably already have a debugger on the machine. The major problem with bugs in production is in the absence of supporting tools.
Better testing
The truth is when automated testing is still under-development you still need to do manual testing. A poor testing methodology costs a lot of money in wasted time and can result in a reducing the scale of return.
For instance, if your testing process is too thorough, your developers will be producing new features faster than you can test them, and you end up with a backlog of features waiting to be deployed to production. The same could happen if you don’t have the correct scale between how many people you have in your QA and in your DEV team.
Always add unit tests when software errors are found. It is a bit more painful when handling legacy codes without a good coverage of unit tests.
Prioritise your bug fixes
Prioritise software errors measuring the impact that they have on the end users. This way will allow you to allocate your resources accordingly, saving valuable costs throughout the SDLC and reduce the cost of software errors.
Software errors expose your end users to slow, buggy software, compromise the security and safety of your products. Many businesses don’t have visibility on their software errors, so measuring them and their impact can be hard.
Software errors were responsible for a majority of the software failures in Government, entertainment, finance, retail, services and transportation in 2016 thanks to research conducted by tricentis.com:
What’s worse is software errors have multiple consequences varying on impact, so you can’t always pinpoint the cause and effect. The effects trickle down ultimately to:
- Developer costs spent on finding and fixing errors
- Ongoing lost revenue from unsatisfied customers
Using a few industry averages, we can help you calculate the cost in lost development time for your company.
How to calculate the cost of developer labour caused by software errors
Taking the industry averages from 2018, we can estimate the financial costs to your company and investigate where the money is going.
- The median developer wage for the UK April. 2018 £30,651
The errors in your applications need to be fixed or they will affect end users and cause lost revenue. This is where support costs start to mount. Fixing software errors is low cost, reactive work.
You should be aiming for around 20% reactive work (finding and fixing errors, support costs), 80% proactive work (building features and improving product) rather than vice versa. This is where you’ll add the true value to the business and your users according to Raygun.
Based on a 40 hour work week at the average wage of GBP £30,651, the average software developer could spend 8 hours each week (32 hours each month). Costing around £6,130.20 per year, fixing errors and replicating issues.
This is time spent away not building new and important features for your customers. So, think twice when building your QA team and not bringing key people to earlier stages of a new implementation. Share as early as possible, gather opinions and different perspectives of the platform.
Resources:
http://blog.celerity.com/the-true-cost-of-a-software-bug
https://crossbrowsertesting.com/blog/development/software-bug-cost/
https://raygun.com/blog/cost-of-software-errors/
https://www.synopsys.com/blogs/software-security/cost-to-fix-bugs-during-each-sdlc-phase/
Building a sudoku game with Kotlin
Hi guys,
The instructions with the steps are available here. Below you can find the exercise done in parts:
You can find the first part here: https://github.com/anikiki/sudoku-init-part1
The second part: https://github.com/anikiki/sudoku-init-part2
And the third part: https://github.com/anikiki/sudoku-init-part3
If you are wondering what you have done wrong, you can check the solution for each part below. Don’t cheat, this is for after you have tried the exercise by yourself first:
https://github.com/anikiki/sudoku-solution-part1
https://github.com/anikiki/sudoku-solution-part2
https://github.com/anikiki/sudoku-solution-part3
Her contacts:
Thanks Ana for this workshop !
Author
