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:
Here’s a high-level breakdown of broadly what each level of testing entails:
The section below delves a little more deeply into each testing/training category:
“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.
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).
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.
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:
| 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. |
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:
UAT ensures that you as a customer get a solution that fulfills your needs and actually works for you.
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.
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.
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:
Of all the testing that your software goes through, UAT is usually the most important (and the most important one to get right) because:
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). |
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’.