How to Identify a Senior Developer During Interview: 7 Criteria to Distinguish Senior from Mid-Level Developers

How to Identify a Senior Developer During Interview: 7 Criteria to Distinguish Senior from Mid-Level Developers

Looking to add some (more) senior level talent to your development team? But how to identify a senior developer more precisely? How do you distinguish one from an average developer, let's say? What are those key technical skills and specific traits that define a senior software engineer, more precisely? 

Traits which, once detected, signal to you that you're looking at a senior developer during the interview process?

Now, you do agree that it's precisely these particular skills and traits that make the best criteria for assessing seniority, right? Allow me to list some of them so that you can use them for evaluating candidates and filtering out the mid-level (and junior) developers.

1. But First: What Is Meant by "Leverage Developer" More Precisely?

What defines a mid-level software engineer? It's only logical that you should be able to pinpoint its main characteristics in order to distinguish him/her from a senior developer, right?

Here's some sort of a "definition":

A developer capable to solve a given problem. He/she makes it work, whether he fully understands the logic behind it or not. Next, he focuses on the next task.

2. What Does It Mean to Be a Senior Developer? 6 Distinguishing Traits

The first "myth" that I rush to bust is that:

"Experience is the ultimate criterion for assessing seniority."

False! Having extensive experience, as a developer, having spent a significant amount of time coding, doesn't automatically make one a senior developer

Instead, there are other specific traits or better said "indicators" of seniority that have nothing to do with a given set of competencies or with the "time served" as a developer. 

In other words, a senior developer is one who:

  1. refactors his/her code till it reaches the highest standards of quality
  2. has made a habit of reviewing his code and clearly explaining his decisions and the reasoning behind his solutions to certain challenges; and also a habit of asking for constructive feedback from his peers
  3. solves a given problem and ensures that he fully understands how precisely he will have managed to make it work, once he has
  4. has an innate curiosity and is constantly looking to enrich his skill set and knowledge
  5. is fully aware that extensive testing makes the difference between sloppy and flawless code
  6. is never too "lazy" to properly document his code for all those developers who might use it in future

Note: it's not the languages that one "speaks" or the frameworks that one uses that make him/her a senior developer. It's a constantly evolving industry, after all. Instead, it's the:

  • continuous strive to grow and to outgrow himself as a developer 
  • proven problem-solving skills, backed up by an above-the-average curiosity to understand the mechanism that triggers the solutions
  • understanding of software craftsmanship,  “shining through” one's own coding practices

… that define a senior developer.      

3. How to Identify a Senior Developer: The Interview 

Ok, now that we've settled:

  1. what is meant by “leverage developer”
  2. what it means to be a “senior developer”

… allow me to share with you the main criteria to use for assessing and evaluating your candidates' seniority. Criteria that I shall present in the form of 7 senior developer interview questions:

Note: it's up to you, to how you want to organize your hiring process, whether prior to the face-to-face technical interview you give all candidates a take-home coding challenge.

Now let us assume that your discussion will revolve around a given business problem that the interviewed developer will need to solve:

To develop a customer-facing web application that would enable users to log in, view and edit data freely on their User detail page.

Here are some of the most relevant questions to ask:

3.1. “What type of web application architecture would you choose? And Why?”

Here, you could encourage him/her to share with you the solutions he'd use for preventing certain unwanted scenarios, such as:

  • circular dependencies
  • the risk of others accidentally compromising the app's architecture

3.2. “Which language (and framework) would you use for building it?”

“Which one for the front-end and which for the back-end?”

3.3. “What security concerns do you anticipate, given the app's “user-facing” nature?”

3.4.“And how would you mitigate those security risks?”

Pay attention to the solutions that the so-called senior developer comes up with for overcoming particular security challenges such as:

  • CSRF attacks 
  • Direct object references
  • SQL Injection 
  • XSS attacks 

3.5. “What type(s) of testing would you perform on this application?”

And here, do encourage him to detail a bit on the types of tests that he'd use:

  • integration tests
  • performance tests
  • penetration tests
  • unit tests
  • acceptance tests

… and on the specific libraries that he'd select for this scenario.

3.6. “How would you document your code so that whoever reads it after you can easily understand it?”

Here, your “how to identify a senior developer” dilemma might just get less... “acute”, depending on the candidate's answers to related questions, such as:

  • “Precisely how much documentation do you think it will be needed?”
  • “And where should it be based?”

3.7. “How do you keep your work skills up to date?”

Ask him to list some of the conferences that he's attended and to briefly talk about what he's learned there, how these meetups have helped him enrich his knowledge.

Also, do feel free to inquire about the blogs, books and other resources that he uses for improving his skill set.

4. 3 Mistakes to Avoid When Recruiting Senior Level Talent

Mistake No. 1: Overrating Resumes' Relevance

Do keep in mind that resumes, pretty much like job listings, are strategically designed marketing tools. No need to give them ALL the credit.

That because a resume would always:

  • outline the candidate's strongest skills and competencies
  • intentionally “overlook” the poorly developed ones
  • focus too much on work experience and not at all on the candidate's future plans (he/she might be no longer interested in doing the same type of work that he does at the current job, and maybe it's precisely that position that caught your attention in his resume in the first place...)

Instead: evaluate his public contribution rather than his resume: BitBucket, GitHub etc. Has he attended any conferences or even given talks on various technologies there? Technologies that are relevant precisely to the vacant position in your company?

Mistake No. 2: Relying on HackerRank or Codility for Tracking Senior Level Talent 

Let's assume that delving into your candidate's open source project (if there is one out there) isn't enough for assessing seniority. In this case, you might as well let HackerRank or Codility “do the work” for you, right?

Well... you'd better not! Here's why:

  • the business problems that they challenge developers with are more often than not poorly worded
  • moreover, anyone can easily Google the answers to those suggested problems 
  • they time candidates' answers
  • they aren't equipped to properly analyze the tested developers' code

Instead: the “how to identify a senior developer” question has another valid answer:

By using a paid coding project to evaluate candidates' technical skills!

Once they've solved the problem, just do a code review with them...

Mistake No. 3: Expecting Senior Software Engineers to Just... Barge In

If you walk on the very same beaten paths during your hiring process:

  • list your job on your careers page
  • … on job sites
  • refer potential candidates that you meet at conferences to your careers page

… then do expect leverage or enthusiastic junior developers (at most) to apply only.

Just face it:

Unless you're Google or Facebook, no senior developer would just fall in your lap just because your job description says that:
  • you're particularly agile
  • you “juggle with” the latest disruptive technologies
  • you burst innovation
  • you have ping pong tables

Instead: court candidates as you'd court customers; craft job descriptions as you'd design your products.

What kind of people are you looking for specifically? What skills and special traits would they need to have to perfectly fit the vacant position?

Based on that, start crafting your job description. One strategically aimed to target and to attract senior developers having those particular characteristics.

The END! These are the dos and don'ts that I recommend you to consider when dealing with a “how to identify a senior developer” type of dilemma before an interview.