You’re probably thinking that in software development, the terms “junior”, “mid-Level”, and “senior” are just labels – and you’d be right. But, whether you like such labels or not, they are useful because they make it possible to discuss a set of expectations for a particular role. Yes, this is an oversimplification, but it’s a useful one. For example, you don’t want to hire a junior developer to architect a major upgrade to a legacy system. Likewise, you don’t want to waste your time (or candidates’ time) by interviewing candidates who don’t have the right potential. In fact, you don’t even want completely unsuitable candidates to apply in the first place.
Your aim is to create teams with the right balance of junior developers (aka entry-level developers), mid-level developers, and senior developers. In this way, you’ll develop a culture that can lead to top-class information sharing, which will get tasks done and save money at the same time.
Junior vs middle vs senior developer
Junior developer vs mid-level developer and senior developer. There are many real differences between junior and senior developers. As a general rule, the question of being a junior, mid-level, or senior developer doesn’t have much to do with how many years of experience a given candidate has – a junior developer can even be older than a senior developer. It is partly a question of the knowledge and technical skills which candidates have acquired. But, above all, it has a lot to do with how a developer perceives their work, how they interact with their peers, and how they approach problems. In this sense, the label of junior, mid-level, or senior refers above all to a certain level of maturity.
Main requirements for a junior developer
When it comes to junior-level positions, the main requirement is that candidates have the ability to perform technical tasks independently. Frequently, the mindset of a junior developer revolves around just making the code work. For example, if the project is based on the same kind of architecture (and assuming that such an architecture is either well known or well documented), then the junior developer should be able to implement the next piece of the application’s logic fairly quickly. Junior developers are not fully independent and will need to discuss how to implement certain elements of the project. Remember that junior developers write fancy code, as they find it hard to write straightforward code. They will also need to review their finished code with a more senior software engineer. This also means that you can expect that juniors won’t understand all the nuances in a project and they will make mistakes from time to time. For the record, junior developers are not expected to design any part of the architecture of the software.
Qualities of a junior developer
When it comes to recruiting a junior level developer, you’re looking for candidates who have a certain level of maturity. In this case, you’d like candidates to demonstrate qualities such as:
- The real desire to develop and learn
- Willingness to learn from their own mistakes
- Ability to accept (constructive) criticism in a calm way
- Genuine energy and commitment
How to interview junior developers
Candidates for a junior developer post must show that they:
- Have been through the whole development cycle at least a couple of times
- Possess some knowledge of the relevant programming language and technology stacks
- Have some knowledge of most of the processes involved in creating software
- Are very keen to learn more about everything involved in making software
- Are able to find solutions to small issues
- Can be productive in working on a specific feature of the product
Please provide an example of a situation when you:
- Took the initiative to solve a small, but significant issue
- Were able to support the team, even if though you disagreed with the team
- Were empathetic towards a new starter
Mid-level developer vs junior developer and senior developer
Main requirements for a mid-level developer
When it comes to mid-level positions, the main requirement is that candidates have the ability to perform tasks independently. This is not the same as the main requirement for junior developers, as the word “technical” has been deleted from the definition. Of course, as long as mid-level developers are not assigned highly complicated technical tasks that require an in-depth level of knowledge, they should be able to complete those tasks independently. However, at this level, developers must also understand the business requirements, and then be able to translate them into technical solutions.
Mid-level developer vs junior developer and senior developer
Qualities of a mid-level developer
Mid-level developers must be able to understand exactly what a given application does in a given context. As a result, they will be able to gain a deeper understanding of any task. And therefore, they can evaluate changes more accurately, and implement them more effectively. At the planning stage, a good mid-level developer must be able to read the requirements and know that something is missing or can be improved. On the other hand, junior developers will probably implement exactly what is stated in the requirements. This means, that an application works correctly (according to the “happy path”), but might crash after the user takes some non-standard action.
Developing code is a team effort, so standardization is very important, as it allows a new person to quickly understand what is what, and minimizes the number of errors. Understanding the structure of a typical application makes the task of building it fairly straight-forward. This, in turn, allows for discussing the principles of correct implementation and distinguishing good code from bad code. A mid-level developer is certainly familiar with standard templates and solutions when building an application in their field. They are not only familiar with certain solutions, but genuinely understands why they are needed, and knows when and how to apply them for the best effect.
A mid-level developer knows how to interact with other team members efficiently and effectively. And this particularly applies to those situations when it is difficult to reach consensus. For example, this is relevant when discussing more subjective elements of a design, when clarifying requirements which are inherently incomplete, when there is some kind of serious time-pressure, or when discussing a major change in the way of working.
How to interview mid-level developers
Please provide examples of situations when you:
- Were prepared to take on tasks that no one knows (or wants to know) how to fix
- Were able to find a balance between complexity and performance in solving a complex technical problem
- Played a major part in creating requirements analysis
- Were involved in testing software
- Played a major part in creating documentation
- Took the initiative in solving problems and fixing critical errors
- Had to work on several projects simultaneously
Senior developer vs mid-level developer and junior developer
Main requirements for a Senior developer
A senior developer has seen a lot of code, made a load of mistakes, and has drawn the right conclusions from the total process. All developers ask questions, all the time. The difference is that, compared to the types of developers with less experience, senior developers know how to ask the right questions at the right level of abstraction. A senior developer’s main responsibility is always to ensure that the right decisions are taken (with the available information at a given moment), decisions that create the maximum benefit to the business, and minimize costs. A good senior developer is always looking for ways to gain more value but is also aware that it is necessary to make the best use of resources, like time and money. A good senior is always thinking about the end-point, so they can often solve problems even before these appear. For example, they think in advance about the bottlenecks of the system, remember vulnerabilities and problems caused by the improper use of tools. Code written by a senior developer will be made with maintainability and scalability in mind.
Qualities of a senior developer
A good senior developer must:
- Be able to solve several complex tasks (and faster) than a mid-level developer
- Be able to distinguish between a product which is “good enough” from one which is either too good or not good enough
- Know how technical debt manifests itself. How much refactoring costs in real terms, what patterns are really needed, and when to draw a line when it comes to levels of abstraction
- Have outstanding communication skills, because they must not only tell others what the “right decision” is, but also convince their client and the team to agree with them. An authoritarian approach (“do as I say”) will often lead to more conflicts, which means there is no progress in improving the overall situation.
- Be able to explain and justify any important decision in a way that can be truly understood by all concerned. In this way, the team itself has the chance to learn from its experiences, and so develop more rapidly, whilst avoiding most of the pain points along the way.
There are many important differences between junior, mid-level, and senior developers. When hiring any type of developer, it is important that you consider the entire package of skills that each developer brings to the table. A lot of people pay attention to the years of experience, which is important, but you also need to hire people on the job they are capable of doing, not what they have done in the past. Therefore, if you come across a developer who is showing a lot of promise, it might be a good idea to take them on and allow them to grow professionally.