Questions to Ask Freelance Developers
Tags: startup, freelance, questions
Published: 2020-09-18 17:47:57

Companies are increasingly turning to freelance developers for the benefits that they provide. This includes the ability to hire for skills that are highly aligned to their job requirements and also get them onboard quickly. In parallel, even the number of developers taking up freelancing is growing each year.

Therefore, a robust process needs to be designed to comprehensively evaluate and choose the right developer for your requirements. Let’s see why this is so critical.

##Need for Holistic Evaluation of Developers

Firstly, it is paramount to have a streamlined evaluation process as it helps in:

1. Minimising the amount of time spent on evaluating developers
2. Finding the best developers for the role
3. Decreasing drop-offs during the process

Also, we need to recognise the reason behind hiring freelance developers in particular, as opposed to in-house developers. Ideally, you are looking for someone who is an expert in their field. They should be able to ramp up quickly, effectively understand what your team is trying to achieve, and then slot in seamlessly.

Hence, the freelance developer should be able to communicate well, be proactive enough to foresee problems, and take independent decisions while working remotely.

So, you need to evaluate the developer’s ability to excel in all of these parameters, rather than just their technical ability. This makes the case for a ‘holistic’ view in the evaluation of freelance developers.

##Skills to Look for in a Freelance Developer

There are some common qualities that all great freelance developers possess. Let’s look at those qualities in a bit more detail:

###1. Technical Proficiency
New full-time employees typically have an induction period. During this period, they are trained and given exposure to the organization. In contrast, freelance developers have limited onboarding time, and need to ramp-up quickly. Moreover, there tends to be more scrutiny on their productivity from the very beginning as compared to full-time employees.

Hence, freelance developers have to be technically strong in their domain to hit the ground running. Here it is key to identify the particular skill sets required for your project. It then makes sense to give precedence to testing those skills rather than generic coding aptitude and learning ability.

###2. Communication Skills
Since freelance developers are typically located remotely and don’t work out of your office, strong communication skills are super-critical.

Poor communication can lead to misunderstandings and could also potentially hinder the formation of trust. This happens, especially, at the beginning of an engagement, where both parties are still adapting to each others’ working styles.

A good freelance developer, therefore, should err on the side of over-communicating at all times – both, written and verbal. This involves being responsive over the agreed communication channels, expressing articulately, and with clarity.

Some of the red flags to look out for are:

- poorly written emails
- a need to follow-up multiple times
- lack of clarity in their messaging
- failure to acknowledge deadlines during the hiring process

###3. Ability to Work Independently
As discussed, freelancing is largely a remote exercise, with opportunities for F2F interactions being sparse. Hence, freelance developers must have the ability to independently make decisions that are aligned to the success of the project.

Further, remote work involves a lot of diversions and challenges. Being able to overcome these obstacles and to consistently deliver quality is critical. This requires staying focused & proactive, managing time effectively, maintaining good documentation, and the ability to work comfortably with tools that aid remote working.

It might be difficult to gauge a freelance developer’s proficiency in the above-mentioned skills. However, a good indicator can be their prior record of working under similar conditions for other remote teams.

###4. Punctuality & Reliability
It is imperative that the freelance developer is punctual. This holds not only for delivering the required code on time but also for team meetings, stand-ups, etc. If they aren’t punctual, they would be hampering the productivity of the entire team. When opportunities for interactions are already limited, the effects of this are even more pronounced.

In addition, they must be reliable and deliver on their promises. Again, since it is hard to objectively gauge a developer’s punctuality or reliability, insights from their past client references would help a lot.

You can also assess this, in part, based on the interactions with the freelancer during the evaluation process. Look for responsiveness to replies, reliability in the delivery of even non-work related items, etc. Before starting the engagement, it is also advised to have a short-term trial project (even paid). This would be beneficial to both parties, to assess fit.

##How do we Evaluate Developers at Flexiple?

At [Flexiple](https://flexiple.com), we have evaluated 16,000+ freelance developers across the world over the last three years. As one can imagine, this wouldn’t have been possible without a streamlined process. We had to iterate multiple times to arrive at our 6-step screening process. We ensure that we have a holistic view of every developer and strive to optimise for the time & effort of all parties involved.

To help others who would like to implement a similar evaluation process, we have detailed the same below.

###1. Depth in past work
We ask each developer to fill a simple profile form. This form includes a generic description of oneself, the technologies they are proficient in, and their CV. We then review developers based on the years & quality of experience and complexity of products built. The answers given by the developers also help us gauge their written communication skills.

Only the developers who display depth in experience and have worked on end-to-end projects are selected for the next step, which is an introductory call. This helps us to focus and deep dive into the most promising candidates.

###2. Good communication and motivation
Over a call, we use the notes made in the previous round to test the depth of the developer’s experience. We ask probing questions about the products they’ve built. We are hence able to test their ability to answer questions comprehensively and in an articulate manner. This helps us understand the confidence they have in their abilities and also the quality of verbal communication.

On the non-technical side, we also achieve a deeper understanding of the developer’s motivation to take up freelance, past remote working experience, and the challenges that they’ve solved. These inputs help us assess if they are a good fit for our network.

###3. Strong technical abilities
Over one or more F2F interviews, we comprehensively assess the developer’s involvement and their performance in building complex software products. This sets the platform to delve deeper into technology-specific discussions where the developer’s knowledge in specific technologies can be adjudged.

This step requires the involvement of senior tech experts. The insights obtained in this step allow us (and similarly could help you) to match the freelancer with the right projects based on their skill sets.

###4. Keen problem solving and coding
A good developer needs to have a mix of good technical experience and also problem-solving ability. To test their technical proficiency, we use skill-specific problems. To adjudge their problem-solving ability, we use a live coding test involving algorithmic problems.

These tests allow us to mimic a real-life, high-pressure situation. Thereby, we can get a proxy of how a freelancer might react and perform in similar circumstances.

###5. Splendid reviews in a background check
As discussed earlier, client references are a great way to get valuable insights into how a developer performs in real-life situations. We obtain inputs on a variety of qualitative factors such as reliability, punctuality, communication, and responsiveness. This is very helpful as such inputs are otherwise difficult to assess only though a 1-on-1 screening.

###6. Consistent exemplary performance
While the evaluation to this point is extremely comprehensive, consistent performance during each engagement needs to be delivered. Our developers are expected to maintain Flexiple standards across all engagements with our customers. Even you should keep regular appraisals to ensure that performance remains exemplary.

This continuous evaluation is carried out by considering a host of factors. For example, the quality of code delivered, documentation practices followed, the ability to ramp up, and softer aspects of responsiveness, reliability, etc.

##Important Questions to Ask Freelance Developers

To help you in evaluating freelance developers, we’ve listed some important questions to ask them. However, keep in mind that this list is designed for people with no technical background. If you do have tech experience, [such guides](https://flexiple.com/php/#hiring-guide) might be more helpful.

The questions are categorised into the following sections:
A. Technical skills
B. Soft skills
C. Aptitude skills

###A. Technical Skills: 5 Questions to ask Freelance Developers
These questions aim to evaluate a developer’s technical know-how and hands-on experience:

1. How many “production-level” applications have you made in the said technology? Can you please share links to the same?
2. What was your contribution to <this> project? (Refer to a particular project)
3. Please describe one of the most challenging projects that you’ve worked on. Can you please explain your contribution to them?
4. What challenges did you face in it, and how did you overcome them?
5. Can you share the highlights of your overall freelancing experience? What type of clients have you worked with?

Look for these outcomes:

- Experience in said technology is solid
- Individual & independent contribution is significant
- Can articulately explain work

###B. Soft Skills: 4 Questions to ask Freelance Developers
You can ask these questions to gauge a developer’s soft skills:

1. What is your motivation to take up freelancing? OR Why have you chosen a career as a freelancer? What’s the motivation?
2. What are the challenges that you face while working remotely? How will you resolve them?
3. What does your remote work set up look like and how do you maintain productivity?
4. <Explain your company's team structure> Have you worked in <such teams> before? Could you please share your experiences?

Look for these outcomes:

- Motivation to freelance shouldn’t reveal a lack of ownership
- Has the right skills to work remotely
- Good alignment with your team’s culture

###C. Aptitude OR DS/Algo Questions
Here’s an example of a Data Structures/ Algorithm question that you can ask to assess the developer’s aptitude and efficiency in problem-solving:

(Q) Given a string containing just the characters ‘(‘, ‘)’, ‘{‘, ‘}’, ‘[‘ and ‘]’, determine if the input string is valid. An input string is valid if: Open brackets must be closed by the same type of brackets. Open brackets must be closed in the correct order. Note that an empty string is also considered valid.

```
$result = hasMatchedParenthesis(")("); 
echo $result;
function hasMatchedParenthesis($string) {
        $len = strlen($string);
        $string_check = 1;
        $stack = [];
        for ($i = 0; $i < $len; $i++) {
            switch ($string[$i]) {
                case '(': array_push($stack, 0); 
                break;
                case ')':
                    if (array_pop($stack) !== 0)
                        return 0;
                break;
                case '[': array_push($stack, 1); 
                break;
                case ']':
                    if (array_pop($stack) !== 1)
                        return 0;
                break;
                case '{': array_push($stack, 1); break;
                case '}':
                    if (array_pop($stack) !== 1)
                        return 0;
                break;
                default:
                       $string_check = 0 ;
                break;
            }
        }
        return ($string_check ? empty($stack) : 0);
}
```
The above code will input 0(false).

##Closing thoughts

The implications of making a bad hire are too pronounced – delays in product development cycles and lost opportunity costs. Often, it might be tempting to rush through the evaluation process to save effort and time. Especially, if you’re dealing with hundreds of applicants. However, it really pays off to do a thorough assessment of candidates.

If you don’t prefer the painstaking process of evaluating freelance developers yourself, skip the hassle and check out these [top websites to hire freelance developers](https://blog.flexiple.com/toptal-alternatives/).