What Is The Cost Of Bug Fixing And How To Optimize It In 2024

Bug fixes, and cost of bugs in software are a headache for every website owner. According to the Herb Kranser report “The Cost of Poor Software Quality in the US” the cost of software bugs in 2020 was ~$607 billion only in the US.

But before we begin, here’re the materials you might also need:

• 7 Steps of Project Discovery Phase You Should Know to Avoid Failure
• Software Requirements Specification – Why does your startup need it? How to make it right?
• Monetization. Or What is Pricing Strategy and why it’s important to work on it for Startup?
• From MVP launch to first active users. What’s next?
• How to hire a dedicated development team: 9 steps to simplify the hiring process

In a perfect world, your platform should work flawlessly without any program bugs after development and launch. But in reality, all software has bugs. So, for optimization and bug fixes, we would like to share with you our experience and knowledge about bugs and defects in software development. We would like to help you to cut errors, flaws, and failures in the website work and, as a result, cut the cost of software bugs. Thus, this article will provide you with in-depth knowledge about bug meaning in software in the following sequence:

1. What Is a Software Bug (source, impact, lifecycle)
2. Types of Software Bugs
3. Most Common Reasons Why Software Have Bugs
4. Bug Life Cycle
5. Cost of Fixing Bugs
6. Software Bugs Examples
7. Conclusion

When you Google “all software has bugs,” you’ll get millions of results. So, the next question is, “Why do software bugs occur?”, “How to identify software bugs?” and “What is the cost of fixing bugs?” This blog post aims to answer these questions in simple terms.

1. What Is Software Bug?

A Software Bug is a failure or flaw in a program that causes it to produce an incorrect, unexpected result or malfunction. Sometimes such errors are minor and impact the platform in very few cases, but sometimes we meet critical bugs that drive websites to crash, freeze, or even leak the customers’ personal/payment info.

Bug problems differ from minor error messages on the screen popping up for a second to significant issues like pages redirecting in an infinite loop.

Software bugs’ causes might be different. As humans write program code, the source of program bugs might result from human logic mistakes during the programming process. Besides, bug defects may be caused by poor requirements, architecture, or design. Yet, some software bugs occur from errors in translation between various languages made by compilers, which build incorrect or illegible code. Occurring, testing, and fixing program bugs is a normal part of SDLC (Software Development Life Cycle).

As a business owner, you clearly understand that your website is an official representation of your brand. It generates leads and builds credibility with your customers. Thus, you should understand the bug meaning in software. Bugs and defects on your website can be frustrating and costly. Even minor software bugs can harm user experience and create the risk that users won’t purchase your product.

Let’s take an example. Imagine that you decide to build a new social platform for pet owners. You create free registration for pet owners and paid registration for businesses that would like to present their products or services for pets on your platform. The platform is done, and you have already invested thousands of dollars in marketing to attract initial users. You don’t want to wait for further testing and spend your budget on it right now. So you launch it as it is. Your dream is about to come true.

Early users found advertisements for your startup, and even though they had never heard about your platform before, they caught your idea. It’s fresh, unique, and engaging. They decided to try it now and devote their time to the registration. They spent about 15 minutes filling down all the needed fields, but the button “finish” didn’t work when everything was done. Why? Because of the bug in the registration form. Put yourself in those early user’s places. Do you think they’ll spend their time on it again? The cost of such a bug is huge.

The budget is drained, which can be an instant “game over” for a startup with limited resources. The first impression is terrible, the initial audience – lost. Unfortunately, not every business can recover from that, this early on the way.

If you want to avoid such failure of your startup, you should take a closer look at software bugs, their types, and their lifecycle. Learn how to reduce the cost of bug fixing before launching and during the project.

History of the term “software bug”

The first recorded use of the term “bug,” referring to an error or a glitch, goes back a long time. Thomas Edison used this term far back in 1878. But much possibly, the term bug was in common use even earlier. Yet, the most famous early application of the word “bug” as a computer issue was in Rear Admiral Grace Hopper’s logbook entry, “First actual case of bug being found.” In 1947 she traced an error while working on the Harvard Mark II computer. It was an actual moth stuck in a relay. So, the first “computer bug” was a literal bug in a computer. What a coincidence.

But let’s get back to the modern days, and now, when you have a general understanding of what software bugs are, it’s time to move forward! Diving deeper, we’ll sort out the actual types of software bugs that can occur during your product development journey.

2. Types of Software Bugs

All bugs have one thing in common; they all are different. We don’t even notice some software defects, while others make the team drop everything and immediately focus on fixing the problem. And there’s a clear reason for it. Correct classification and prioritization of software bugs help optimize bug fixes and reduce the cost of the bug-fixing process. If you know what you are dealing with, bug fixes can be assigned to the appropriate team and removed fast and efficiently.

Generally, all bugs can be classified: by nature, priority, and severity.

Software Bugs by Nature

Software bugs have various natures that affect the software’s overall functioning. The most common bugs in a web application can be classified into 5 types by their nature:

Performance bugs

Performance bugs in code may affect software’s speed, stability, response time, and resource consumption. For example, if you notice a slower loading speed or response time, then it states in the requirements, it might be a performance bug. Such kind of program bugs is detected by performance testing.

Security bugs

Every 11 seconds, a business fall victim to a ransomware attack. According to FBI IC3 reports, the costs of cybercrimes have increased to $10.2 billion over the past five years. Therefore, security is increasingly important to users and website owners.

Yet, poor security may ruin your company’s reputation and can cause a personal data leak. In addition, security bugs threaten a potential illegal security attack, unauthorized access, or control of a whole computer system. Therefore, to minimize the risk of security bugs, the development team must make particular focus on security testing. More about Types of Cyber Attacks and when startups need Cybersecurity here in one of our previous articles.

But here is the good news. The new study by ShiftLeft, the 2022 AppSec Progress Report, shows that only about 3% of today’s flaws are reachable by attackers. So, to reduce the cost of bug fixing, it’s better to hire an experienced, dedicated development team that will focus on fixing and mitigating truly attacking types of bugs. You can learn How to hire the best Dedicated Development Team here in our article.

Functional bugs

A functional bug means that some feature or the entire software fails to function as expected due to an error. The severity of such bug types depends on the feature which they impact.

For example, you might notice it when the minimize button closes the program. The other good example is when the buttons “Submit” and “Cancel” positions and/or colors are mixed up. They may work just fine but cause a lot of misunderstandings and frustration, ruining the user experience. The testing team does functional testing to identify this type of software bug that is causing functionality errors. Once identified, QA decides on the priority and launches the bug-fixing process.

Usability bugs

If the developed web application is not convenient enough, it might be usability bugs. Usability bugs make software difficult to use and negatively affect a user’s experience. Such type of software errors makes your website or app over-complicated. For example, you can discover them when your users can’t log in, update their profile, or can’t find a shopping card. Therefore, before launching the product, it is important to run usability testing according to usability specifications and Web Content Accessibility Guidelines (WCAG) to identify and reduce the cost of such bugs.

Software Bugs by Priority

Thankfully, we can prioritize bugs and make the bug fixes logically and gradually. That enables the delivery of software products on time. Software defect prioritization allows focusing on important and urgent tasks so that you can later concentrate on lower-priority bugs.

Software bug priority levels are determined according to the impact of these bugs on the business and user experience. First of all, the testers will analyze the nature of the bug and then the defect priority. Such steps let us determine the timeframe and overall cost to fix the bug.

Usually, there are four priority levels of software bugs: urgent, high-priority, medium, and low-priority.

• Urgent Priority bugs. Urgent defects may destroy the brand’s reputation and drastically affect the user experience. In most cases, they require fixing in the shortest notice.

• High-priority bugs. We assign bugs and defects to high-priority levels if they affect the most crucial software product features and make them unusable. Therefore, even though it may not affect every user, it is mandatory to fix these bugs before any further development steps.

• Medium-priority bugs. Medium-priority bugs may cause some undesirable or unexpected behavior and may not affect every user. However, the system is still functioning, and the application is not affected significantly. Such software defects could be fixed in the nearest release.

• Low-priority bugs. Low-priority defects do not affect the functioning of the website or application. It is more about aesthetics. The bug may bother you but won’t cause any significant system breakdown. The low-priority bug should be fixed once all bugs from higher priorities are fixed.

Software Bugs by Severity

The severity of bugs prioritizes the technical impact of the bug on the overall functionality or performance of the software. The severity of software bugs is a key to prioritizing a defect.

There are five severity categories of the bugs: blocker (S1), critical (S2), major (S3), minor (S4), and low/trivial (S5).

• Blocker (S1). Such an error may cause security breaches, data loss, or shut down applications. As a result, the product is unusable until the bug won’t be fixed.

• Critical (S2). It is an incorrect work of a core software functionality, like installation problems or failure of its primary features.

• Major (S3). An error significantly impacts an application, while other inputs and features of the system stay functional, so it’s still possible to use it. However, bugs of major severity have to be taken seriously as they can cause ripple effects and collapse of the whole system.

• Minor (S4). Such a defect is confusing but doesn’t cause any disruption of website functionality. Bugs of minor severity have minimal impact, and core functions of the product work as specified.

• Low/Trivial (S5). A bug doesn’t affect the functionality or isn’t obvious. It can be a UI problem, such as incorrectly sized buttons, spelling issues, object color issues, etc.

Now you know the types and classifications of software bugs that appear in your product development way. But why do software have bugs in the first place?

3. Most Common Reasons Why Software Have Bugs

As it was stated before, there is no such thing as bug-free software. However, looking into the root causes of program bugs is vital for the software development life cycle. By deep understanding where bugs might appear and their types, it’s possible to establish better ways to avoid errors in the future. We, at AMgrade, aim to find and fix the problems as early as possible so that users do not experience them and your budget won’t be wasted. So we’ll gladly share our experience on the most common reasons why software has bugs.

Overall, most of the mentioned reasons can be considered Human factor, we still wanted to separate them a bit for you to easily ‘diagnose’ similar issues in your processes and define the influencing factors to keep an eye on. Let’s get to it!

Human Error

Humans are humans, nobody is perfect. So no wonder – human mistake is one of the most common reasons why software bugs occur. Of course, you can’t miss out on the factors like – not following coding standards which lead to poor quality code or lack of practical developer experience, but there’s more to it. If none of these two options is the case, make sure to track the work-life balance and processes.

Chronically tired and overwhelmed people tend to make more mistakes. Is this a surprise? Not at all. Many researches over the years, proved the contribution of overtime, and stressful work environments to anxiety, depression, and sleep deprivation. Work quality suffers in these conditions. The cause behind the burnout of your employees needs further ‘investigation’ but may correlate with the next factor in our list.

The other point worth mentioning as a factor that causes the program bugs to slip – is skipping the testing phase with the professional QA department. Sometimes in order to “save” the budget clients prefer to do the testing themselves. Lack of previous experience with testing and methodology can lead to major and critical bugs ending in on live. As a result an even bigger budget would be needed to fix this after launch.

Unrealistic Deadlines

It’s not a secret that time the product hits the market is crucial, but non the less adequate development deadlines are as important. In the planning stage, many business owners fall into the trap of treating project estimations as strict deadlines. We, at AMgrade, make sure to “include” the risks in all estimations and discuss every point with the clients. Still, depending on the product’s complexity, time and budget estimations often require a lot of guesswork. Plus, our standards don’t apply to all of the teams/vendors out there. So make sure to bring this question up before starting the development process.

More about the Software Development Estimation and its creation process here in our earlier article. It can help you find out what you can do to get a more exact estimation!

Rushing the product launch may force the team/vendor to make compromises (such as cutting the time for certain functionality development, missing on the self-testing before giving the code to the testing team, looking for shortcuts like third-party options, etc.), which definitely increases the chances of bugs appearing.

Poor Project Documentation & Miscommunication

These two factors are closely related and even can resolve each other, unless both are neglected. For example, if the customer isn’t clear about what they want to achieve and provides poor to no documentation in the initial stage, there’s still a good chance to implement the high-quality product.

Communication is the key here, competent Project Manager should step up in the process, get all necessary details from the client and form proper documentation for the development team. And it works the other way around too, with detailed documentation and clear vision from the very beginning it’s possible to cut the communication to a minimum without quality loss.

In both of these cases, lack of information and guesswork on the engineers’ end can cause software bugs. 

Requirements Changes On The Go

Customers may not fully understand or be not informed about the possible influence of changes after the development process begins. The closer to release – the riskier. Changes to the infrastructure, architecture and tools used may conflict with the current structure and cause the launch delay or missed bugs.

Combining the risky changes with the release time pressure makes a ‘deadly’ mix. Testing vital features, compatibility with browsers, and database migrations made in a hurry are no good.   

But what if the client is informed about the risks but still needs these changes? How to plan them right? In these cases, the client must lengthen the timeline for the release, and the QA department must adapt and be ready for additional testing stages to keep the unavoidable bugs from getting through.

Third-Party Tools

Third-party tools such as class libraries, external APIs, HTML editors, shared DLLs, and add-ons/plugins (especially WordPress development) are often decent solutions to save time. But there’s a catch –  solutions like this can have bugs of their own.  

Even when the product is released just fine, clients tend to make updates themselves, not wanting to engage with the developers again or save the budget. This approach may lead the newer version of tools to conflict with the existing code, leaving the new pack of software bugs with different levels of severity.  

As annoying as it may be, bugs will always exist, and a variety of mentioned reasons just proves the point. But with proper planning and an efficient software testing process it’s possible to find and fix most of them.  

Moving forward, precise bug classification and prioritization would help to speed up a bug-fixing process and save a lot of money for the business. Once the bug is found and ranked, it should go through the life cycle to be closed.

4. What Is a Bug Life Cycle

A bug life cycle or a defect life cycle is a set of statuses that help to optimize a bug fixing in web development. Clear identification of bug status keeps the development team and stakeholders of a project informed about the progress. The cycle starts when a QA engineer reports a new issue and finishes when this issue is fixed.

Workflow of bug life cycle consists of:

• New. A defect is found and forwarded to validation.
• Assigned. The project manager assigns the bug to the developer. 
• Active. The developer fixes the defect, and an investigation is in progress. There are three possible results at this stage: further Test, Deferred, or Reject.
• Test. The tester re-tests the code.
• Verified. If the bug passes tests, then it is verified by QA. If not, the case is reopened and assigned to the developer again.
• Closed. The final state of the bug life cycle. The case can also be closed if the defect is a duplicate (found and assigned before but not fixed yet) or considered as NOT a defect.
• Reopened. When the defect is NOT fixed, QA reopens/reactivates the bug.
• Deferred. The bug cannot be resolved in that particular cycle. It is deferred to a future release.
• Rejected. A defect can be rejected if: it is a duplicate defect or is considered as NOT a defect or non-reproducible.

A bug life cycle may vary depending on a product type and project development strategy. Understanding a bug’s life cycle helps monitor and correct the developing process if necessary. In addition, following the defect life cycle workflow in the testing minimizes the risks of mistakes and enables the team to release the product sooner.

5. Cost of Fixing Bugs

Bugs in code should be found and fixed during the testing phase of the web development life cycle. Otherwise, the real impact of software bugs might cost more than we can imagine. For example, the research of the Systems Sciences Institute at IBM shows that the cost to fix an error found after a product release costs from 4x to 5x times more than the one uncovered during the design stage. Moreover, it costs 100x times more when software bugs are identified in the maintenance phase.

Clearly, it’s harder to fix issues when the product is launched and released. The later bugs are tracked, the more negative consequences they have and the more complicated they can be to resolve. Furthermore, late and slow bug fixing can affect product functionality and brand image. Moreover, late bug fixing causes further code changes that might conflict with the initial one – adding to the cost, time, and effort. So it’s essential to track and fix bugs during the early stages of development.

How Much Would Bug Fixing Cost You?

In one of our previous articles, “How to hire a dedicated development team: 9 steps to simplify the hiring process” – read here, we showed statistics on the average hourly rate of software development worldwide. Due to this data, we can calculate how much bug fixes cost globally.

The average time to fix the functional (major level) bug before the launch stage is around 12 hours. So, to count the cost of fixing a bug, we take the developer’s hourly rate multiplied by the time to fix it. Here is what we received:

Now it would be much easier to calculate and understand the cost of the bug fixes in the maintenance phase. Simply multiply all those numbers by x100.

The high cost of late bug fixing is not the only problem. Business owners should consider that fixing bugs in the already released product causes a domino effect. When developers begin to change and fix one part of the code, it ripples on other parts of software code, sometimes even on the website design. Thus, delinquent bug fixing might provoke the second round of SDLC, adding an extra cost to that code change.

Due to late bug fixes, your customers receive a slow and buggy application. You lost your revenue. Moreover, instead of releasing new product features, improving user experience, and moving forward in product development, the engineering team stucks in the fixing process.

According to the CPSQ report, in 2020, the total Cost of Poor Software Quality in the US was $2.08 trillion, and here you can add minus customer interest, plus failed IT projects and time lost. To avoid failure of a new project, we should strive for about 20% reactive work (finding and fixing defects, support) and 80% proactive work (building new features and improving our product). If you delay bug fixing, you start a snowball effect and get 80% reactive work compared to only 20% proactive.

As a matter of fact, delayed bugfixes can affect everything in your business project. It starts from budget overruns, low revenue and results in indirect costs like customer loyalty, brand reputation, wasted time, and the slow death of a project.

The total cost of software bugs can be hard to specify, but a detailed understanding of what software bugs is, and their impact on your business is the first step to reducing wasteful spending. Prioritizing, timely fixing, and focusing on critical errors profits with a successful project and reduces costs.

6. Software Bugs Examples

Many project stakeholders make one common mistake. They suppose that if the system works, they should release it as soon as possible and test it during maintenance. We would fix those small defects, later on, they say. What is more, to save the project budget, they choose to test themselves only with the help of bug tracking software. Wrong. 

Testing and fixing bugs is an integral part of any project development. We can compare it with the clean-up after renovation. You won’t be happy to move into a house with a cloud of dust, debris, and toxins and say I would clean it someday, later on. We would say it’s close to one of the interesting topics – Technical Debt, yet it’s not particularly only about delaying testing and bug fix, but overall a similar concept. You can read more about Technical Debt here in our previous article.

Or, let’s take another example. Even though in the car industry, most of the work is done by robots, the quality control and correction of even minor defects is made by humans. The same thing with the aircraft industry. You won’t sit on a plane if you hear an announcement: “Dear passengers, the cost of your tickets was so low because we would test this plane later on, during the flights.”

Why early bug tracking and fixing is so important? Because everybody knows that even a tiny bug may cause big troubles. Here are examples of the big companies that choose the hard way to learn that.

NASA

You might think that in spacecraft engineering, there’s a lot that could go wrong. Yes, that’s right. Moreover, NASA had several failures because of the bug. On July 22, 1962, their spacecraft Mariner 1 probe heading toward Venus was destroyed just in 293 seconds after launch. Why did it happen? Engineers missed a hyphen in the code. Because of this, the spacecraft was “wrecked by the most expensive hyphen in history.” The cost of program failure was $18.5 million in 1962. Today the cost of such a mistake could be approximately $554 million.

Did they learn the lesson and start to make better testing? Not so fast. In 1999, NASA’s Mars Climate Orbiter got lost in space after a 286-day journey from Earth. Spacecraft orbited too close to Mars’ surface and disintegrated. The reason was that one engineering team used English units of measurement (inches, feet, and pounds). In contrast, the other team used the more conventional metric system (millimeters, meters, and kilograms) for key operations. At the end of the project, two teams forgot to convert different systems into one. The cost of a bug in code is $125 million. 

One more punch for NASA was the Genesis crash in 2004. It was meant to bring back space material from beyond Earth’s moon. Genesis returned to Earth three years after takeoff with samples of the solar wind for analysis. But it didn’t land smoothly. It crashed in Utah. As a result, many of the probe’s precious samples were destroyed and polluted, though some were recovered. A NASA report released in 2009 said that Lockheed Martin workers had inverted the position of the probe’s accelerometers. Hence, the spacecraft never knew it was decelerating into the Earth’s atmosphere and, therefore, never deployed its parachute. This gap in testing cost NASA over $260 million.

Apple

Like many others, Apple doesn’t release totally bug-free software. Some of them we can see every day, but they don’t really bother us. But the other cost a lot to the company.

In August 2022, Apple announced serious security vulnerabilities for iPhones, iPads, and Macs. They allow potential hackers to take complete control of these devices. As a result, security experts have advised users to update affected devices.

The company did not explain how, where or by whom the vulnerabilities were discovered and how many people were affected. In all cases, it was mentioned as an anonymous researcher. But they said it is aware of credible reports that flaws had been “actively exploited.”

Such serious flaws are valuable for hackers and vendors who are ready to pay a lot to access them. While the bug was tested and tracked, Israeli firm NSO Group has allegedly hacked high-profile journalists and world leaders. They could spy on the target’s contents and surveils in real time. Now the U.S. Commerce Department has blacklisted NSO Group. Nevertheless, the damage is already done, and the consequences remain classified. The cost of such a bug would be calculated when the investigation would be finished and closed.

PayPal

One of the largest online payment platforms in the world, PayPal, has also faced a lot of troubles because of software defects. One beautiful morning Chris Reynolds from Pennsylvania became reacher on a $92 quadrillion thanks to a small PayPal error. They accidentally credit this amount of money to his account. What a surprise to Chris it was when he checked his monthly statement. But such an error was quickly recognized and fixed. By the time Chris Reynolds had logged in, his account had returned to zero.

One more severe security bug in PayPal that they have from 2021 isn’t fixed until today. This new unpatched bug lets hackers steal money from PayPal users. With the help of this program defect, attackers can trick victims into unknowingly completing attacker-directed transactions with a single click.

The attacker may use clickjacking, also called UI redressing. With the help of such a technique, unwitting users are tricked into clicking seemingly harmless webpage elements like buttons to download malware, redirect to malicious websites, or disclose sensitive information.

Hackers fool users by displaying an invisible page or HTML element on top of the visible page. As a result, PayPal’s users think that they are clicking the legitimate page while they are in fact clicking the rogue element overlaid atop it. Result of a bug – stolen money by one click.

Knight

What if some computer bug made you buy high and sell low? What if such a bug would cost you $440 million? Unreal? But that’s exactly what happened to Knight, which nearly bankrupted them.

In 2012 Knight was the largest trader in the U.S., with average daily trading of over $21 billion. In August morning of that year, Knight activated a new trading software… with a bug. When New York Stock Exchange opened that day, the faulty software sent Knight on an acquisition spree. Soon it was buying shares in about 150 companies worth about $7 billion in the first hour.

According to the stock exchange rules, Knight must pay for those shares three days later, but they couldn’t as they had no source of funds behind them. Of course, Knight tried to cancel the deal, but the chairman of the Securities and Exchange Commission, Mary Schapiro, refused. Only six stock transactions were reversed. 

When Knight understood that the trades would stand, they had to save themselves by selling off the stocks for nothing. Goldman Sachs stepped in and bought all of Knight’s unwanted positions for $440 million. By the next summer, the company was acquired by its competitor, Getco LLC. 17 years of dedicated work disappeared in less than one hour.

What went wrong? Several factors caused the failure. Yet, one of the most important was a flag that had previously been used to enable Power Peg was repurposed for use in new functionality. In other words, the program believed it was in a test environment and executed trades as quickly as possible without caring about losing the spread value.

The Security Exchange Commission’s report highlighted many other factors. Yet, the critical factor was missing formal code review and unit QA process to check that the software had deployed correctly.

Conclusion

We have as many testers as we have developers. And testers spend all their time testing, and developers spend half their time testing. We’re more of a testing, a quality software organization than we’re a software organization.

Bill Gates

We all make mistakes, and developers are no exception. However, when the business stakeholders see an already made product, they feel the dream is so close to coming true that they start rushing with the release. They think fast launching would start to make money, and only then would they begin handling those small errors. But without quality, it doesn’t matter how good your idea is and what is the cost of a product. There would always be somebody with a better product and a lower price.

The quality of your software product is a result of continuous testing and improvement. Even though it looks like testing and bug fixing takes a lot of effort, time, and money, you should realize that software released with bugs is not what your customers expect from you. It’s just a bunch of expensive mistakes. Brand loyalty, revenue, investments, and project success result from high quality and bug fixing in the initial stages.

Software bugs and errors may be caused by faulty code, requirements, poor architecture, or poor design. Understanding bug types and proper prioritization helps build a structured QA strategy and deliver high-quality software at speed.

Sure, testing, bug fixing, and great quality product cost money, but the cost of fixing bugs during post-release and maintenance phases may be overwhelming and ruin the brand. So never underestimate QA testing and timely bug fixing. It’s a secret to reduce the cost of a bug and overall development project.

We in AMgrade know the real cost of the bug, so our experts always aim to fix it at the earliest stages of the software life cycle. Our mission is to mitigate risk areas within the development process while bringing high-quality functional products. We realize that the worst bugs are simple mistakes that could have been caught through quality analysis at the right time. Therefore AMgrade comes with a warranty that includes support, bug fixes, and workarounds.