In the world of software, app, and web development, functional testing is critical. It ensures that your product functions as designed and without unexpected results, errors, or other bugs that can cost you sales, customers, and your brand reputation.
Functional testing can take on many forms, depending on your goals, the needs of your customers, and the design of your product. But having to hire testers to walk through every button click, dropdown, and text input in your source product can cost a lot of time and money—and that compounds when you need to test all the localized builds as well.
Here are some tips to maximize your testing budget, while still conducting thorough testing and producing a top-quality global product.
1. Start at the source
The oft-heard phrase “Quality at source” means being proactive in your approach to software development and localization. It’s writing code that clearly separates functionality from the user interface (UI), allowing the text to be easily extracted for translation. It encourages internationalization best practices—making your product localization-ready—through providing flexible support for cultural and linguistic differences such as character sets, currencies, and date and time formats.
It also includes thinking about potential localization issues that could arise, such as truncation or overlapping of UI content, and defining requirements and restrictions to prevent them. If a linguist translating the software strings gets clear instructions at the start about maximum string lengths, they can effectively provide correct translations up-front, rather than need to edit strings later during testing when they see a mess in-product.
This approach certainly takes more time in the beginning—doing it right often does—but it pays off significantly down the road as builds and languages multiply the testing scope.
2. Test each element, but not everything
With all the various combinations of operating systems, devices, browsers, and languages that your software supports, you’d be testing every build for weeks on end. The answer? Pairwise testing.
This is when you take stock of all the possible combinations of technology and languages that your product supports or runs on, but you generate a matrix of test environments such that every element is tested only once, as opposed to in every single combination.
We’ll explain this concept further in a future blog post, but the point is that pairwise testing can significantly reduce the amount of testing you need to do, while ensuring that each product variant gets tested.
3. Automate whatever you can
Many components of testing, or perhaps entire test cases, can be automated to speed up work, reduce testing time, and allow testers to focus on more complex tasks. There are many automation tools currently on the market, such as Ranorex, Silktest, and Selenium that can crawl URLs, fill out forms, and take screen shots. Your own software development team might be able to write scripts and executables to automatically walk through the application and perform certain tasks, since they are the most knowledgeable about the product’s ins and outs.
Even if your software is difficult or impossible to automate, you can still use automation to save time. For example, you can use automation techniques to generate nightly builds of your software. You can prepare complex testing environments—deploy clean operating systems, install your software, and configure the workspace—so that the testers do not need to spend time and money doing that manually. They'll have everything ready and can start immediately when their PC boots up.
Of course, the initial scripting investment yields more benefits with larger language scopes (the more testing you do, the bigger the savings), but even if it chops your source language testing time in half, that’s a big win.
4. Focus on the features
Most software follows an agile development methodology these days. This practice is all about developing software updates and releases in small, short cycles, focused on the most important features, to release bug fixes and new functionality to the market faster. Hence, your testing should follow a similar process.
Maybe you don’t have time every single cycle to test everything, but build testing in at regular intervals—perhaps before every major release—with test cases that focus on the features your customers demanded. If you’re worried about potential bugs in legacy features too, use some of those fancy automation scripts to find those bugs so you can fix them.
5. Go virtual
Between ever-improving cellular data networks, cloud-based apps, servers, and storage, and high-speed internet, virtual testing allows the whole world to be your testers. A few methods include:
- Emulators: software that mimics a computer or mobile device. For example, you can install an Android emulator on an Apple phone.
- Virtual machines: a type of emulator that imitates a desktop machine, such as a Windows or Linux PC installation, right down to setting hardware specs like RAM, video card, and CD-ROM.
- Remote machine connections or VPNs: connecting directly to another physical machine or network.
This technology provides a wide variety of benefits. You can source testers from anywhere in the world, with the exact experience, language skills, and product knowledge you need. They can often test on devices they already own, avoiding breaking the bank on buying, configuring, and shipping dozens of devices—or flying everyone to your office. Lastly, your software team can set up and preconfigure the virtual environment ahead of time. Not only does this provide greater control over the testing environment and avoid troubleshooting tester installations, it’s a safer way to protect your IP and send your unreleased app out into the world.
Naturally, implementing a combination of these techniques will compound the benefit. But each one can bring significant ROI to your testing program, allow you to test more functionality and features, and release products of stellar quality.