You’re about to invest in a new software solution or enhance existing functionality. You’ve got your software partner, spec’d out your requirements, had the necessary workshops and have received your official proposal… but it’s got odd things included like QAT (Quality Assurance Testing), UAT (User Acceptance Testing). Do you really need all this stuff? It’s expensive and seems like it adds extra time to the deadline. And like, you need this software YESTERDAY. What’s going on??
Yes. Yes, you need these things. You really do. Especially if you want your (let’s face it, sometimes hefty) investment to pay the returns you’re expecting. QAT and UAT provide progressive and context-specific testing and should be included as a standard within every software development project. Their inclusion is designed to ensure a few specific operational goals:
- That you end up with a good quality piece of software that works as expected (This is QAT)
- That the end result is usable, that the provided/developed design specification was actually correct, and that the correct operational assumptions were made (This is UAT)
Here’s a high-level breakdown of broadly what each level of testing entails:
- QAT (Quality Assurance Testing): Examines whether the software performs as specified. This is usually done in-house by your software development partner, and by a team of specifically qualified and trained testers. The idea is to identify any bugs or deviations from the expected design.
- UAT (User Acceptance Testing): This is usually done by an individual/small group within your own company. The idea is to have your staff actually use what has been built, to examine if it works as needed and if any changes need to made to layout, design, processes, functionality etc. This is essentially beta testing.
The section below delves a little more deeply into each testing/training category:
1. Quality Assurance Testing (QA)
What is QAT?
“Simply put, Quality Assurance Testing is designed to ensure that the developed software functions as the customer requested”
[Braam Bosman, SOLIDitech Quality Assurance Manager]
QAT ensures that your software performs within the parameters set out by you and your development partner; in other words, it must perform as designed.
Who performs the QAT?
The process sees specially trained Quality Assurance Analysts (QA’s) examining the new code or feature and performing comprehensive software and user interface testing in a controlled manner at each stage of the project (usually on a separate testing environment).
When is QAT performed?
This depends on the project management techniques applied to the development of your software project and the needs of the client. Generally, it’s seen as good practice to start testing a new piece of software as early in the project’s lifecycle as possible. That also gives QA’s the opportunity to be involved in the design process. This process continues for each piece of functionality until development of the project is complete.
How is QAT performed?
Although exhaustive testing on a piece of software is impossible, a QA Analyst will perform a number of well-developed testing techniques during the lifecycle of a project. Both functional and negative scenarios will be tested and any defects or possible improvements will be communicated to the developers.
As an example, our Quality Assurance Team will:
- Analyse design specifications done by the customer to draw up test plans and test cases
- Test software for scalability, robustness and maintainability
- Identify interactivity and usability flaws within user interfaces
- Identify functional defects and business rule deviations
- Work together with our experienced software development team using software development lifecycle tools and methodologies, including bug tracking and quality assurance management software
- Assist with software build, merge and release control processes
- Produce software user guides
What are the benefits of QAT?
| Risk Mitigation | Testing the new code or feature mitigates the risk of problems arising once the project is deployed to a live environment. |
| Quality Control | Testing ensures that only high-quality software is delivered that performs as designed. |
| Cost Reduction | The QA Team tests and works closely on any fixes with the development team as they move through the project. There is, therefore, less time wasted on reworking entire projects later down the line. |
| Client Confidence | A competent Quality Assurance team will inspire confidence from the client in your business that a good quality piece of software will be delivered. |
2. User Acceptance Testing (UAT)
What is UAT?
The keyword for this type of testing is ‘user’. Essentially, UAT is the process of verifying that the solution works for the user (e.g. the client).
The idea here is this; technically the software might have been developed exactly as understood by the developers and Quality Assurance Analysts, but does it actually work for the end-user? UAT tests the actual usability of the solution.
This phase of testing accounts for:
- Any differences between the developer’s understanding of the requirements and what is actually needed
- Any changes in requirements during the course of the project that might not be communicated effectively to the developers
UAT ensures that you as a customer get a solution that fulfills your needs and actually works for you.
When is UAT performed?
UAT is the final phase of testing that your software project goes through once all the development work and QAT has been completed. It typically happens just before a piece of software is released, but some customers prefer to do it only after it's been released to their Production environment. In such a case, it will be done in a strictly controlled manner (eg. using test accounts). It’s important to note that for smaller pieces of additional functionality, this process might not always be necessary to include.
Who Performs UAT?
UAT is performed by actual software users. Techopedia explains that during UAT, actual software users test the software to make sure it can handle required tasks in real-world scenarios, according to specifications.
A good person to perform UAT would be one of your own staff members or a small team within your working environment.
How is UAT performed?
Your user/team of users work through the software, using it to perform either real or hypothetical operations, all the while testing usability.
Usersnap have a great list of example scenarios that are questioned throughout the UAT process:
- Can the user use the software?
- Is it really what they asked for?
- Do they have trouble using it?
- Does it behave exactly as anticipated?
What are the benefits of UAT?
Of all the testing that your software goes through, UAT is usually the most important (and the most important one to get right) because:
- They capture user requirements in a directly verifiable way,
- They identify problems which unit or integration tests might have missed,
- And they provide an overview of how “complete” the system is
When done correctly, the benefits include:
| Improved staff satisfaction | Your end-users (the staff) end up with a solution that they can intuitively understand and that works in the way they are expecting it to. UAT is also extremely useful with much larger projects when considering a change management strategy. |
| Cost Savings | You are not investing in an ‘un-tested’ solution which may have to be completely re-worked later down the line to include a variety of usability or operational improvements. |
| Time Savings | Similar to the above point, you are not wasting time on the same project twice (or in the worst case, more than twice). |
Conclusion
Both QAT and UAT are essential components of a successful software project. They provide progressive and context-specific testing to ensure that you end up with a good quality piece of software that works as needed.
Strong software project management, effective communication, good feedback loops, testing, technical understanding and customer involvement are all cornerstones to a strong client-developer partnership. Let me talk you through each of these for this ‘ultimate software project management guide’.
Comment