A sanity check is a quick and easy method to sift out bugs, logic flaws, or usability issues that are fundamentally flawed without getting bogged down in rigorous test cases and documentation.
Due to its quick nature, the idea of a sanity check is to sift out results that are outrightly false early on in the product design/development lifecycle, rather than catching every possible error in various fields that usually comes under the remit of more rigorous testing further in the lifecycle.
An example of such quick tests can be illustrated with simple arithmetic. When multiplying by 9, we can use the divisibility rule for 9 which is 'the sum of the digit is a multiple of 9'. By verifying whether the sum of the result is a multiple of 9, we can quickly assess the validity of the result. Although this method won't catch all the multiplication errors, it can alert us to a lot of errors.
For example: 9 x 57 = 513
5+1+3 = 9; the result is divisible by 9
This means that the result is likely to be true.
In computer science, similarly to arithmetic, a sanity check is conducted as a very brief run-through of a computer program to test whether its functionality performs as intended; followed by a more thorough round of testing.
Technically speaking, it's performed on a stable build to ensure that all bugs are resolved and that there are no live bugs introduced due to changes in the code or functionality of the software product.
What makes sanity testing unique is it's very much scenario-dependent. There is no hard and fast rule. The main objective is to ensure no bugs or usability flaws are present in new components and that new components do not affect the functionality of the old components by following the three simple rules below:
Below is an example of how one would conduct a sanity test.
Imagine a scenario where there are various different modules. Among those modules is the login page where the username requirement is more than ten characters. Whenever a username with less than ten characters is created and accepted, it leads to a bug.
The role of the testing team is to spot the bug and report it to the development team to fix it. Once the development team fixes this issue, they report it back to the testing team for another round of inspection. The testing team proceeds to check and ensure that the bug is fixed as well as checking that it's not affecting other modules' functionality.
Taking a step back from the technical intricacies of software sanity check, even when designing, it’s easy to get caught up with incredible visuals, animations, typefaces without a deeper understanding of usability implications and/or considerations.
For instance, regarding exporting images used in the final build of a digital product — it might be tempting to just use a raw image without cropping or resizing it appropriately, but this leaves your browser to dynamically resize images is generally not a great idea as it leads to significantly usability implications.
This is just a simple example to illustrate that oftentimes we neglect user sanity in favor of aesthetics, but best in practice designers can ensure to balance these often overlooked intricacies and considerations.
Sanity Testing is only one type amongst many other types of more rigorous software and usability testings. However, despite its relatively simple nature, its efficiency in sifting out bugs and fundamental usability flaws without the need for complex documentation can tremendously save unnecessary testing effort, time, and resource waste.
Knowing when to utilize different methods against the circumstances and available resources is critical. At Mäd, we have compiled a list of methods to help navigate the human-centered UI/UX design landscape. Amongst the many UI/UX methods, Heuristic Evaluation is a quick useful method to discover usability problems with fewer resources than would be warranted from methods such as stakeholder and user interviews.