Hiring an external freelance tester is one of those options in today’s workforce landscape that some see as a necessary evil, others as a great benefit, but that nearly every software QA team eventually faces:
- Sometimes you need a few extra hands on deck for a short term.
- Other times, you want access to outside expertise.
- And you’re always looking to better manage your budget.
Because we’ve already covered the pros and cons of bringing in outside help, we won’t revisit those points again. Instead, this article assumes you’ve already made the decision to outsource certain aspects of the job. And it outlines how to maximize the benefits of that approach – benefits that will only become more pronounced as society continues to shift towards an XaaS or “everything as a service” model.
Fading are the days when companies only outsource services (SaaS), platforms (PaaS), or even logging (LaaS). It is becoming easier than ever to “rent” temporary talent. In fact, we do precisely that at Testuff whenever we need to bulk up our own workforce for a particular project.
But this unprecedented ease also brings unprecedented challenges.
Let’s take a look at how you can more effectively navigate this changing landscape as the global pool of freelance talent becomes larger, more diverse, and harder to manage.
1. Finding the Right Candidate
Whether you’re hiring a full-time employee or a temporary freelancer, many of the “recruitment” tips from this earlier article apply. But there are certain hiring criteria that are specific to outsourced talent.
For example, it is critically important that you identify and define all required attributes in advance.
And here’s why.
You don’t have the luxury of training freelancers over time. Whomever you hire needs to have the requisite skills to get started ASAP.
Moreover, when you post a freelancing job online, it’s not uncommon to receive tens (if not hundreds) of applicants.
This 2nd point is crucial. You need a way to easily filter out unqualified candidates using strict criteria, such as:
- Practical knowledge of testing technologies.
- Proof of relevant work experience and logged hours.
- Language proficiency (communication is essential).
So for example, your advert might stipulate that candidates have “at least 100 hours of previous experience testing WordPress interfaces.” And you might also require that all applicants have “excellent Spanish skills.”
2. Outlining Project Scope and Deliverables
Poorly defined expectations often lead to wasted time and higher costs. However, you can maximize limited resources by clearly defining the tools, methodologies, and environments in advance.
You should also invest time identifying how all results should be captured and reported. This is especially important for debugging since insufficient communication will create redundancies (at best) and latent defects (at worst).
This project scope analysis is where you define the “how” of the testing and reporting. It can be a time-consuming process. But this type of advanced planning will produce far superior results – often at a much lower cost.
3. Providing the Right Tools
Communication is important. We can’t stress that enough. But unnecessary back-and-forth interactions can sometimes create inefficiencies.
Ideally, your freelance tester should be able to start on the project with minimal feedback. By providing your freelancer with all documentation, tools, and logins upfront, he can continue working without interruption.
Depending on your project, it may make sense to define “stop” conditions if certain events are triggered. For example, if an agreed-upon process cannot be started, the test should be temporarily paused until you’ve had a chance to look into it.
Done correctly, your next contact with the freelancer won’t be until the project is “finished.” The ultimate goal is to avoid micromanaging as much as possible.
However, that doesn’t mean you should avoid monitoring. With periodic reports, you can make sure the tester is on the right track. It also helps if you remain reachable at all times. In fact, you should encourage your freelancer to come to you with any questions the moment a problem crops up.
4. Analysis and Summary
Your freelancer is ready to report that all milestones are officially completed. But before you sign off on the project, you must first examine if:
- The deliverables match up with the original project scope.
- The bug reports are helpful, actionable, and complete.
Here’s a useful way to determine if these criteria haven’t been met.
Look for bugs that were closed because they were “incomprehensible” or “could not be reproduced.”
Anytime developers close defects for these reasons, it means they didn’t understand the bug report. More work needs to be done – until those defects are marked as “fixed” or “resolved.”
Another red flag is when too much unnecessary communication exists between your freelance tester and your development team. Defect reports should be thorough enough so that exchanges are kept to a minimum. With detailed reporting, developers should be able to easily reproduce and fix bugs on their end.
In other words, the less back-and-forth, the better.
You’ll also need to decide whether validation is done by this tester, or perhaps leave it for your own testers. Sending back fixed bugs for validation, to the tester who found then, is of course the common approach, however in this case it requires finding the right work flow and process to manage it (how the tester know bugs were fixed, where does he sees the fixes, etc.).
Navigating the Freelance Testing Landscape
Outsourcing can be a cost-effective way to find great talent. But navigating the freelancing landscape isn’t always easy. And if you misstep, you might end up with worse talent at a much higher price.
Using the strategies above, hopefully you can avoid this fate.
If you have outsourcing tips of your own, we’d love to hear them.
When hiring freelancers in the past, what did and didn’t work for you?
Share your experiences in the comments below.