Technical Screening in 2022: 15 Methods for Assessing Senior and Junior Developers

Selecting the right technical screening methods to properly assess the skill and experience level of job applicants during the hiring process can help to distinguish between Junior developers and Senior developers. It’s important to understand the job description and requirements for the role you need to fill, so you don’t try to hire an under-qualified Junior for a Senior role, or expect a Senior to work for a Junior pay rate.

Senior level talent is the foundation for any development team and can be a leading factor in the level of success your development team sees. Junior level talent is often filled with potential and promise and can be trainable to meet your goals and objectives. The screening process helps to distinguish each candidate’s level, and how they might be able to help your organization.

Below is a list of popular screening methods for developers, and how they might help you to find the right candidate for your development team. When it comes to filling the position, it helps to know what you’re looking for. But first, it may be helpful to discuss a little more about the technical attributes that differentiate a Junior developer and a Senior developer.

The Technical Attributes of a Junior Developer

Junior developers may not have proven themselves capable of working independently within the context of a team yet. They may bring a fresh energy to their work, but at the same time will likely need some supervision and guidance. Their presence can increase in value over the long run, as they gain experience and evolve in their careers.

Here are some signs of technical expertise to look for in the screening of Junior developers:

• Coding knowledge (illustrated through a degree, bootcamp, work experience, or coding challenges).
• A proven ability to problem-solve and be resourceful.
• Some level of hands-on experience.
• Familiarity with your company’s core technology stack.

The Technical Attributes of a Senior Developer

Senior developers can work independently or as a collaborative member of the team. Whether or not they take a leadership role, they do not require close supervision. They have a firm grasp of the big picture and how their role fits into it. Beyond their technical skill set, Senior developers should also have the soft skills to collaborate with others and should be willing to mentor colleagues of all experience levels.

Here are some signs of technical expertise for Senior developers:

• The ability to work end-to-end through a software development lifecycle.
• The ability to preemptively account for any potential issues or errors within their work.
• A willingness to keep learning through industry blogs, podcasts, books, or other informational sources.
• The ability to project-manage with minimal guidance on an individual or team level.
• The ability to accurately determine project scope and deliver on time.

The Best Technical Screening Methods for Junior vs. Senior Developers in 2022

Screening and evaluating candidates with the following methods in mind can help you find developers that are right for your organization. To help you use this resource, the methods below are broken down into different sections: Experience Verification, Identity Verification, Skills Verification, and Screening Interviews. Remember, the best tools and methods will vary from organization to organization.

Experience Verification

1. Resume Screening – There is a reason resumes are still a mainstay in any hiring process. They offer employers a clear view of experience and qualifications. The drawback to using resumes in the screening process is time. When you’re staring at a pile of hundreds, if not thousands of resumes, it can be a daunting task to filter through all of them for the most qualified candidates. A professional screening service can help to reduce this burden by pre-screening candidates and sending only the best-suited applicants to your hiring team for review.

2. Applicant Tracking Systems (ATS) – Many screening services rely on technology to automate the resume scanning process by using AI to filter large volumes of resumes based on keywords. This certainly helps them to turn the crank and make the sausage, but it’s hardly a guarantee of quality. In fact, applicants have figured out how to fool this software by formatting their resumes to contain dozens of these keywords in invisible text. Unscrupulous candidates may simply copy the resume of a more experienced developer and slap their name across the top, or even steal the other coder’s identity outright.

3. Public Profiles – Social media profiles such as LinkedIn can give significant clues about a candidate’s professional background and skill set. A LinkedIn profile can be cross-referenced with a resume to find out more. There are also places within a LinkedIn profile for candidates to display references, testimonials, and samples of previous work. All of this applicant data helps in screening Senior vs. Junior developers.

If your open position is a Drupal role, it’s worth checking for profiles at Drupal.org. Those profiles should have project links where applicable, and link to a portfolio. Moreover, Drupal.org profiles also keep track of community contributions, including participation in issue queues (bug reports and patches), edits to documentation, code contributions merged into core or community-contributed projects, and modules or themes released to the public. While it’s entirely possible to find Senior developers whose profiles don’t have much activity (some people only code during work hours or are prohibited from open-sourcing client code), it’s rare to find profiles with a lot of activity that aren’t backed up by the skills.

A quick check on Facebook and other less professional-oriented platforms can also provide telling information. These social media sites can help to determine whether a candidate will provide the right type of cultural fit within your organization. There shouldn’t be any questionable or offensive content in any public profile.

When conducting Experience Verification, differentiating between Junior and Senior developers requires more than simply counting years of experience. Senior experience should include roles with more responsibility, whether leading a team, taking charge of a key element of a project, or completing entire projects as a solo developer. Senior projects tend to be more complex, and project scope should be more ambitious. With Juniors, be on the lookout for steady roles in smaller projects, or supporting roles in larger projects.

Identity Verification

4. Reference Checking – Reference checks are another classic way to screen any new hire. Understanding how they performed with previous hires will go a long way in assessing both Junior and Senior developers. It’s also important to verify that inexperienced developers are not making up job experiences to try and pass themselves off as Senior developers.

5. Online Research – A simple Google search can offer a lot of different types of information on a candidate. If there is a website, public portfolio, or a strong social media presence, this is how an employer may find it. The clues left behind here can be used to assess a developer’s skill set and what role they might fill within your organization.

When conducting Identity Verification, be on the lookout for evidence to corroborate job history and projects listed on resume. Senior developers should have well-documented work experiences, and may even have a short bio on the “About” page of their most recent employer’s website. Juniors should be able to describe their job experiences in convincing detail, including their role in a project and the technologies used; they should be able to produce references upon request.

Skills Verification

6. Project Links – It’s increasingly common for developers to have a Portfolio Website with a selection of Project Links (quite simply, links to a candidate’s professional work that is published on the public Internet). It’s not always possible to assess a candidate’s skill set by simply viewing a website, but screeners can use browser tools to inspect HTML, CSS, and JavaScript sources to determine the tech stack and third-party services used in the project.

In some cases, a project may not have a Project Link: if it is not public-facing (it’s on a client’s private network and requires VPN access, or something else), or not a website (it’s a mobile or desktop app, or something else), or not online any more (but may be archived at web.archive.org). Candidates who cannot share URLs to their recent work will benefit from collecting their experiences in a portfolio website with a gallery containing screenshots and descriptions of the work they did on the project. Even if they don’t have a portfolio website, candidates should be prepared to share Client Websites, Demo Apps, or both.

A Senior developer should have Client Websites that they can share. (Sometimes a Senior developer will have only one URL to share, because they have been working at one company for many years.)

Junior developers may not have client work to show yet, but they can share Demo Apps that are published online. The best Demo Apps will double as a Code Sample, providing their source code in a public git repository.

7. Code Samples – Reviewers should not expect candidates to share source code from client work, especially if doing so would violate a non-disclosure agreement. The flip side of this restriction is that candidates should expect to provide a code sample that is either released under an Open Source software license or in the public domain.

A good Code Sample provides evidence that the developer can write their own code (not based on code from an open source project, or created using a code generator). The code sample does not have to be fancy, but it does need to implement custom business logic (i.e., “do something”) by following the coding standards, best practices, and security recommendations of the platform. The best Code Samples will double as a Demo App, linking to a live demo on the web.

Senior developers should have no trouble sharing a Code Sample, but Junior developers may need to be assigned a Coding Challenge.

8. Coding Challenges – A short coding task for candidates to complete, either in person or remotely, can help a hiring manager to determine the right candidate for the position based on their ability to perform the work that will be expected from them.

The reality is that it’s hard to assess a developer’s ability through interviews alone. Skills assessments such as coding challenges can make it easier to determine a candidate’s skill level. There are various types of coding challenges that can help you to distinguish between a Junior and Senior developer, and make the right selection for your organization. Some of these include:

• Algorithm Challenges – These bite-sized coding challenges can be completed quickly, and sometimes graded automatically. Generally, these are an adequate test of coding style and logical thinking skills, but they may not show a candidate’s ability to code to platform-specific APIs.
• Take-home Challenges – The developer candidate can complete these on their own time, sometimes overnight or over a weekend. These challenges, often based on real-world scenarios, allow screeners to evaluate a candidate’s ability to follow coding standards and best practices of platform-specific APIs.
• Pair Programming – This is a coding challenge that you and the candidate solve together. It’s probably a better option for hiring a Senior developer that may not be overwhelmed with the task of a live challenge.
• Whiteboarding – The candidate would solve this type of coding challenge live and in front of the hiring team. This is better at determining how a candidate handles stress than their actual coding abilities.

Algorithm challenges are quick and easy, and may be included in automated skills testing. Take-home challenges require more time to evaluate, so it does not make sense to require everyone to complete these; they are typically reserved for candidates who have already passed automated skills testing. Pair Programming and Whiteboarding require a significant investment of time and effort from the hiring team as well as the job applicant, so they are best reserved for developers who have already passed earlier rounds of screening.

Senior developers generally write clean, concise, well-structured code. They follow coding standards such as adding doc blocks to all classes and methods, but they don’t clutter up their code with irrelevant comments. They anticipate unexpected inputs, throwing and catching exceptions correctly. They strive to produce elegant, minimal, testable, and maintainable code.

Junior developers often write code that works in a given scenario, but may not be flexible enough to catch exceptions from edge cases and unexpected inputs. They seldom follow all coding standards, and their inline comments may be chatty and redundant. They may repeat themselves or hard-code values that should be configurable. Still, if they are able to get the job done and write code that works, they may be ready to join your team and gain experience.

Take a look here if you’re looking for more information on how to get started with coding challenges.

9. Skills Testing – Many screening services offer skills assessments, which may combine algorithm challenges, multiple choice quizzes and other elements. Sometimes, these assessments may be evaluated automatically by software. Automated tests can efficiently screen huge numbers of candidates in the least amount of time, but run the risk of producing false negative results that can eliminate qualified candidates.

The best screening services will ensure that each candidate is reviewed by a human expert, preferably even before skills testing assessment is assigned. After evaluating Resumes, Public Profiles, Project Links and Code Samples, expert screeners are able to assign an appropriate assessment that tests the skills needed for Junior or Senior roles.

10. Community Contributions – If the candidate has made any contribution to open-source projects, this can be a great place to find examples of their work. Community Contributions may come in the form of bug reports, code patches, documentation, or questions and answers in community forums.

Senior developers are more likely to contribute code patches that fix bugs, while Junior developers are more likely to submit bug reports.

11. Answering Questions on Forums – Community forums such as Stack Overflow, Reddit, or Quora can give a potential employer deeper insight into a candidate’s experience and skill level. It’s important to look at the nature of the questions, and the depth of the answer to determine the level of thought that the candidate put into their answer.

Senior developers are more likely to be the ones who answer questions and solve problems, while Junior developers are more likely to ask questions.

Screening Interviews

12. Video Interview – Video interviews have been an interview staple since 2020 and allow employers and candidates to get face to face without needing to be present within the same room. There are several programs that make this option easier than ever. Here are just a few popular video meeting platforms:

• Zoom
• Skype
• Microsoft Teams
• Google Meet

As the interviewer, you can pay attention to the same factors that you would if the candidate were sharing the room with you. You’ll want to have a list of questions prepared for the candidate to work through. This is the framework for the structure of the interview.

Body language can give you a good idea of the confidence level of the candidate. It’s important to keep in mind that some may be nervous in a job interview environment, and that could impact their body language.

Another factor to watch for in a video interview that wouldn’t factor for an in-person interview is the environment. A neutral background with no distractions is a great way to maintain a professional look. It should be clear that the candidate has considered the lighting as well.

The interviewer should be able to get valuable information from both Junior and Senior developers through a video interview, the way they would in person. Both levels should convey a high level of confidence and professionalism through the interview, but a Senior developer should carry themselves with more confidence. A good list of technical screening questions is important for this method.

13. Asynchronous Video Interview – An asynchronous, or one-way, video interview is an excellent way to quickly assess candidates early on in a job interview process. Candidates love them because they are typically short, and most offer unlimited re-records for those who may be nervous about the quality of their answer, or appearance on video. Employers see a benefit from being able to assess a candidate early in the process, by their answer to a select 2-3 important questions. There’s no need to schedule interviews, and you can watch the videos at your convenience.

14. Other Interviews (Phone, Slack, LinkedIn, etc.) – Sometimes it is quicker and easier to do a screening interview over the phone, or via text messages. Slack or LinkedIn can also be used for this purpose. It can be easier to schedule and a less formal process when a candidate isn’t overly concerned about environmental factors or personal appearance, like they would be with video interviews. Like with video interviews, detailed and thoughtful questions can be used to assess the skill level of the candidate. One word of caution: if you don’t do a video interview, you run a greater risk of being fooled by a fake candidate.

15. Screening as a Service – If you’re short on time or feel like you don’t have the experience or resources, there’s another solution available. You can hire a company that provides screening as a service, such as Esteemed. When you go this route, you can be confident that you’ll have a technical screener with the background and experience to be able to properly evaluate talent. You’ll also have a large pool of pre-qualified candidates to choose from.

The State of Developer Candidate Screening in 2022

Screening developer candidates has become more complex in a remote work environment, but it’s still possible to do it well. Each company will have its own projects, and each role will have its own requirements. Clearly identifying the requirements for your open role should always be your first step. After you’ve posted the job description and the applicants start flooding in, you’ll need every tool available to separate the wheat from the chaff.

• Skills Verification methods, such as skills testing, code review, and coding challenges, ensure that you consider only applicants whose skills fit perfectly into this new role on your team.
• Experience Verification methods, such as review of resumes and public profiles, ensure that your top picks are neither over-qualified for a Junior role, nor under-qualified for a Senior role.
• Identity Verification methods protect you from scammers, fake candidates, and identity thieves.
• Screening Interviews give you the opportunity to evaluate applicants in real-time, to determine whether they actually possess the knowledge they claim or are just good at bluffing.

Evaluate All Your Screening Options

Some of these screening techniques can be quite complex, labor-intensive, and time-consuming – especially if your hiring team lacks the relevant technical expertise. Cutting corners can mean throwing the ideal candidate’s resume in the trash before a human being can evaluate it, or getting tricked into hiring the wrong person. Luckily, you don’t have to screen developer candidates on your own.

An experienced tech recruitment agency like Esteemed can help you to find a pool of experienced, pre-screened candidates to meet your qualifications and needs, with our screening services. Outsourcing your screening frees you from worries about the tech talent shortage and simplifies the entire hiring process.