Quality Management in Software Development

Introduction

Whether you’re building new software in-house, or have decided to outsource the development process, one of the main questions is how the development team can create high-quality software and meet your criteria.

What does a high-quality software system mean?** Is it having high-quality code, minimal defects, or simply staying within budget?**

According to recent research conducted by Truelist, 25% of software development projects fail due to bad project management including unclear requirements, unrealistic deadlines, and communication gaps. Neglecting quality assurance can lead to significant issues down the line, often requiring more resources to fix them.

That’s why software engineering teams should be crystal clear about the possible quality-related costs in the software development process, how they can be managed and prevented to ensure a smooth and seamless experience for the customer.

1. What is software quality management?

Software quality management is about setting and meeting goals to build the best possible system within a given budget, timeline, complexity, and other constraints. Building high-quality software means meeting the requirements of the software system and making sure the end result is aligned with the client’s vision.

1. Why is software quality important?

Software quality is important for one clear reason: not having any quality management plan in advance can lead development teams to perform extensive rework to fix avoidable mistakes.

If achieving a predefined quality is necessary to meet the project goals, then such quality should be ensured from the very beginning of the software development life cycle.

However, it’s also important to note that maintaining clear and fixed quality metrics right from the start is also quite challenging as development is an agile and continuous process, and quality metrics may evolve as the software system grows in complexity.

So, development teams should define at least some clear quality metrics to get started in the software development process. With each step as new complexities arise, new quality metrics can be introduced and continuously monitored.

1. What are Software Quality Management Metrics?

Some common types of software quality management metrics include defect metrics (tracking defects and bugs), code quality metrics, reliability, performance metrics, etc. Our approach is to select the metrics that are relevant to the project goals as well as client’s expectations, and meet quality-related goals.

Sustaining quality metrics ultimately leads to these top benefits:

1. Customer Satisfaction- No major issues that can negatively impact the customer journey and experience.
2. Consistency- Making sure that the software works consistently in the long run and does not cause inconvenience for the end-users.

3. Reduced risks- Financial and functional risks that can impact the quality of the developed software.

4. Key steps in the Software Quality Management Process.

The first step in quality management is to understand that quality is ultimately determined by the end goal. Quality is measurable and some clients may not even ask for software with the highest quality possible, they might simply require a sample version to get started with, test, and grow from there.

Of course, it would be ideal to set a fixed quality threshold right from the start, and hope it would remain the same till the end of the project development process. In this case, the total project costs would cover the entire life cycle of quality-related issues.

However, the reality is usually quite different, so the real strategy can vary from a planned "step-by-step" increase in quality in several stages to periodic creation of new system versions "from scratch," each time with a higher quality threshold.

We like to state that “Improving quality is much more expensive than maintaining it."

This “law” is true not only for developing software systems but also in other areas. For example, it’s easier to maintain your health instead of having to get expensive treatments when it’s too late, ensuring technical maintenance of a car from time to time vs eventually getting a full repair– these examples all follow the same pattern. Neglected cases take longer and are more expensive to fix later than to ensure their quality right from the start.

1. Main processes behind building high-quality software systems.

Qualitative indicators in the development of software systems can be divided into two groups:

• Qualities important to the users of the software (functionality, convenience, speed, reliability, etc.).
• Qualities important for the further development of the system (understandability, simplicity, maintainability, scalability).

Quality Planning

When planning quality, one should consider:

• The system's lifespan.
• Its' expected volume.
• The target function of the software development cost (which costs we want to minimize).

Based on this, you can plan:

1. Several stages of the software system development.
2. Refactoring - reviewing the system architecture by breaking it down into modules at the end of each stage.
3. The optimal quality threshold for each stage and module.
4. When planning quality, one should consider:

6. What are the challenges of maintaining and testing software quality?

Increase in complexity

As mentioned above, one of the main differences between meeting the quality metrics of a software system and most other areas is that during its life cycle, a software system continuously increases in complexity requiring more quality metrics to be set in place.

Meeting initial budget expectations

As the complexity and size of the software system increase, the quality threshold should be raised to achieve the same cost indicators. This can be hard to predict initially, so as a professional who has requested software development services​​, you should be aware that the more complex your software can become, the higher the chances you might have to plan a higher budget for the project.

Delivery dates

Another important factor is being able to meet the delivery dates agreed with the client. If possible, the two parties might agree on extending delivery deadlines to ensure the highest quality for the software before launch.

Cost of improving quality in software development

To understand the costs of improving the quality during software development, it’s important to estimate the cost of failures and deficiencies. However, the cost also includes other factors such as the development cost required to fix the issues. If any customers have been lost in the meantime due to the software system being down, then the lost customer cost can also be added to the list. Depending on your software development partner, the cost estimation process for ensuring quality might differ.

Authors note: If you’d like to learn about estimating custom software development costs, check out our recent article here.

7. Ensuring Quality in Software Architecture Using a Monolithic System

Let’s say one client has requested a standard website while another client has requested a custom “Educational Material Distributed System” (to view our case study click here ). Ultimately, these two projects will not have the same quality measurement criteria (referring to a group of quality indicators important for the system's development).

A standard project such as developing a non-complex web application might have, let's say, 50 defects in the development process, while the custom educational software system if it's 100 times bigger, might have 5000 defects that appear gradually during the life span of the project.

All defects influence each other, creating numerous "degrees of freedom". Therefore, when considering the system's complexity, one should not add up the defects but multiply them - the function "complexity (number of defects)" grows exponentially. And the higher the complexity, the more likely that new defects will arise.

As a result, the larger and more complex the software system, the higher the quality threshold should be to prevent exponential growth in maintenance costs.

One thing to keep in mind is that defect influence gets multiplied only in case of having a monolithic system (in software engineering, a monolithic architecture refers to a traditional development model that uses a single code base to perform multiple business functions). The multiplying is due to the interconnectedness of various components.

• Initial Cost vs. Scalability: Monolithic software development often means lower initial costs but may suffer from scalability issues as the project grows. It's necessary to consider the potential scale of the software system during the planning phase to avoid performance issues later on.

• Defect Multiplication in Monolithic Systems: In real-life scenarios, given the uncertainties in project success, starting with a simpler approach like a monolith is a common practice. If the product succeeds, refactoring becomes necessary to maintain scalability and quality.

• Splitting into Independent Parts: Breaking down the software into independent parts helps reduce the impact of decreasing quality by isolating their influences. In this case, defect influences get summarized and not multiplied. This emphasizes the importance of clear software architecture and periodic refactoring (which sometimes supposes splitting rather complex parts into several simpler pieces).

Please, keep in mind that not all projects can be started as monoliths. Our goal as software engineers is to plan carefully - choosing the architecture to start with and planning the necessary steps if the software is made for businesses with a large number of customers.

Conclusion

In summary, effective software quality management is crucial for achieving successful project outcomes and building high-quality software systems. By implementing quality assurance, control, and improvement strategies, and by continuously monitoring the process, development teams can align with client requirements while mitigating the risks associated with costly rework and defects. Prioritizing quality control early on allows software development teams to identify and address issues, preventing them from escalating into larger problems later in the development cycle and having higher customer satisfaction rates.