Think of the last item you purchased. What factors played into this purchase decision? We’re going to assume price, quality, brand reputation, ease-of-use, and workmanship were all deciding factors.

We want to zero in on one of the key purchasing factors: quality. Quality can trump all other limiters, buyers are willing to overlook a higher price tag, a longer delivery time, or even brand reputation – when they know they’re getting the best quality product possible.

Your customers want the same from your software. However, agile software development methodology has earned a reputation of skimping on quality. All too often internal and external customers believe that it’s impossible to deliver on a quality product within every short iteration.

Long-standing beliefs about what it takes to plan, develop, and test a quality piece of software still have a firm grip on what creates quality. In other words – long 3 – 6 month development and testing cycles, the exact software development environment that created so many problems for so many companies.

The truth is, the reality is quite the opposite. Talk to your team, they’ll agree that the quality of what they deliver at the end of their iteration is of higher quality than anything they previously worked on. The fundamentals of agile software development all combine to make quality a priority: ease of communication/collaboration amongst all team members, continuous testing, daily stand ups, and real team work.

This doesn’t mean that agile software teams can afford to overlook quality and assume it’s just going to happen. Delivering on quality must always be a central focus of the agile software development team.

Quality as a Driver in Agile Software Development

There is no “just good enough” or “we’ll fix it in with a patch” in agile software development. Everyone on the team from the product owner, development team, QA team, and documentation team know that the given iteration is the time to focus on delivering on quality stories.

The nature of agile is to allow for flexibility and change in scope, this in-turn allows the team to adjust their focus from “getting it done” to delivering on completed and successful stories. During the iteration, if the team discovers a blocker or realizes a story is bigger than expected, plans and deliverables for the iteration can be adjusted.

The constant through-out: quality. With a focus on making sure that a given story is correctly coded, tested, reviewed, and documented lends itself to naturally delivering on quality. So, while the story may change or the scope may be adjusted, the quality is still there. Blockers and other problems don’t mean quality is impacted – rather they mean the team has to adjust, work together, reprioritize, and refocus.

For skeptics or those new to agile software development, it often comes down to simply not understanding or seeing how quality becomes the real priority.

How to Deliver and Maintain Quality with Agile Software Development

When dealing with questions or concerns about quality, emphasize the processes integral to your team’s agile software development.

  • Definition of Done (DoD). It’s important that each team member (and product owner) fully understands the Definition of Done (DoD). Moving a story to Done means that a number of key processes were completed including: code peer review, automated testing completed, QA team has fulfilled the acceptance test plans, the scope of the story is fulfilled, and the product owner and/or customer is satisfied.
  • Real teamwork. An agile software development team relies on teamwork for its success. Admittedly, it can be a challenge to align UX designers, developers, QA, documentation, and the product owner. Each brings its own priorities and focus to the team, however, it is this diversity that enables a given story or project to be successful. Slow-downs and blockers can be eliminated when these cross-functional teams are supported.
  • Automated testing. By taking advantage of automated testing tools and practices, QA teams are able to focus on the code. When done right, automated testing frees QA to use their expertise to look beyond the user interface. The integration of both automated tests and acceptance-test plans ensures that all aspects of the feature or story are fully tested and reviewed.
  • Continuous Integration (CI). Gone are the days of weekly code check-ins – now with CI, developers are encouraged to complete daily check-ins. Maintaining good CI practices ensures that code collisions and integration problems are caught early and can be fixed quickly.
  • Pair programming. In teams that have the numbers, it can be advantageous to pair software developers with each other. This pair of developers sit together at one computer: one is the leader and does the typing/coding while the other team member provides advice and looks for areas of improvement and potential errors. While at first there can be a learning curve for developers who are used to working alone, this pair approach does eliminate code errors and defects while increasing the overall quality of the code design and story.

The good news for agile software development teams is that more and more companies are going agile. This only speaks to the benefits of agile – from the people developing the software to the people selling the software to the customer support team to the customer –all are realizing the quality that agile software development fosters. Gone are the days of “settling for second best” or “waiting for the next release” – now companies and customers can get exactly what they want and know they don’t have to sacrifice on quality.