dev seniority levels

Software Engineer Qualification Levels: Junior, Middle, and Senior

A software developer’s career ladder consists basically of three rungs: junior, middle, and senior. The industry applies this terminology to better understand and assign a degree of qualification, as well as determine both salary level and responsibilities.

Being aware of the developer seniority levels will help set more accurate expectations for a particular engineer. Also, this distinction will not only improve internal communication, it will also enhance communication between customers and vendors, making all interaction more effective. By distinguishing these job titles, a client will get a better understanding of the competency levels in the IT industry.

In this article, we will analyze software developer’s seniority according to the following criteria: technical knowledge, day-to-day duties, independent work, interaction with the team, and vision.

Approaches to the expertise evaluation in software development

As part of the seniority level analysis, we’ll describe several existing approaches to evaluating a programmer’s expertise. Applying them to the given gradation will provide a broader perspective of seniority in software development.

The Dreyfus model of skill acquisition identifies 5 stages of attaining and mastering skills. Andy Hunt in his book Pragmatic Thinking and Learning: Refactor Your Wetware applies the Dreyfus model to software development. The author uses the Dreyfus model to structure fundamental changes that occur throughout the learning process. This allows him to juxtapose how programmers at different stages perceive the development process and approach problems, as well as, how they form mental models.

dreyfus model

The five Dreyfus model stages illustrating the most important changes on the way from Novice to Expert Source: Pragmatic Thinking and Learning: Refactor Your Wetware by Andy Hunt

The Seven Stages of Expertise in Software Engineering. This is another approach to classifying expertise in software engineering by Meilir Page-Jones. The classification breaks expertise down into seven stages and uses productivity as the key criterion. Although originally used to evaluate software engineering in the ‘90s, the approach can be easily reapplied to our reality.

Productivity Curve Source: Expertise in Software EngineeringThe Productivity Curve Source: The Seven Stages of Expertise in Software Engineering by Meilir Page-Jones

Programmer Competency Matrix. This matrix of the programmer skillset was developed by Sijin Joseph, a technology leader with over 15 years of experience in designing and building software products. The matrix has a three-level structure that correlates with the Junior-Middle-Senior role distribution. The matrix also includes Level 0 which, in our opinion, equals a Trainee-level Software Engineer. We are going to refer to this source while describing the tech knowledge expectations for each seniority level.

Approaches to expertise evaluation

Approaches to expertise evaluation compared

Trainee: fresh out of school

Some companies have internship programs where they take entry-level engineers who have basically only theoretical knowledge and no work experience. In this case, a beginner’s job title will be a Trainee.

Applying Meilir Page-Jones’ stages of expertise, we chunk this early period in developer’s career into three stages: Innocent, Exposed, and Apprentice.

Initially, engineers have little to no exposure to real development. Exposed developers make the first steps towards coding in a professional way. Finally, an apprentice is already minimally equipped to tackle a real project.

Speaking of technical knowledge, trainees are primarily limited to using IDEs as text editors for coding without leveraging their additional features. They rarely deal with APIs and often have to consult the documentation. Apart from the core platform they specialize in, trainees are not familiar with any frameworks and have only a vague idea of what a database is.

Junior Developer: through trial and error

Getting your foot in the door as a junior developer is difficult because they often come and go. Employers tend to hire junior devs for freelance or short-term contracts with an eye to reducing the contract cost.

Nevertheless, a junior’s trump cards are the motivation and energy that many senior people no longer have. Juniors know the effort they put in will pay off by enabling them to move sooner to the next level.

Alternative approaches. Referring to the Dreyfus Model, we may divide the junior level into two phases: Novice and Advanced Beginner.

To get the ball rolling novice developers need universal context-free rules. Being impatient, they want immediate results. At the same time, mistakes can paralyze them, since they do not know how to handle them.

Advanced beginners start departing from following fixed rules and formulate general principles based on similar situations they’ve dealt with. The main issue is that they overlook the larger context, perhaps considering it irrelevant.

Using the Meilir Page-Jones’ gradation, we may refer to a junior as Practitioner. That is when developer productivity sufficiently increases as they begin to adopt new techniques through trial and error and apply them to corporate projects.

Junior technical skillset and duties

IDE. Juniors navigate the interface and operate IDEs efficiently using the taskbar.

API. They know how to handle the most frequently used APIs.

Frameworks. Junior devs have worked with some frameworks and know about the popular ones that are worth using within their language stack.

Database development. A junior knows DB basic design techniques, ACID properties, and transactions. Also, a junior can write simple, select statements to retrieve information from the database.

Programming languages.  Junior developers are usually familiar with one programming language. They will pick it right away and implement a semi-stable solution that solves most of the problems in certain use cases.

Platforms & tools. Juniors have professional experience with about three platforms. Their knowledge of platform internals is only skin-deep. They are aware of alternatives to popular and standard tools.

Day-to-day duties. Juniors usually get the least complex tasks, those with little impact on the final product.

Junior teamwork and perspective

Independent work. Certainly, juniors need close supervision. They need strong mentoring to grow their skills.

Working in a team, a junior must stay engaged and absorb from the team as much knowledge as possible.

Vision. The problem with juniors is that they are code-focused, rather than development-focused. This prevents them from getting the big picture.

Middle Developer: workhorse of the programming world

Junior devs with generally more than three years of experience can leverage their skills out to become mid-level specialists. Mid-level devs,  sometimes referred to as “the workhorses of the programming world,” deliver the most impact with routine code.

Alternative approaches. The Dreyfus Model describes the middle developer as Competent. At this stage, they can also do a decent job of troubleshooting and debugging.

Competent programmers are highly initiative and resourceful. They pursue leadership roles on the team and can mentor novices. However, competent devs still lack the experience to prioritize the focus of their attention while working on the project, and they are barely able to reflect on their mistakes.

In terms of the seven stages of expertise, we can consider the middle developer a Journeyman. They work on honing their skills and enhancing productivity. Journeymen are competent enough to be the source of Software-Engineering advice.

Middle technical skillset and duties

IDE. After using IDEs for quite a while, a middle dev has memorized the shortcut keys for most frequent operations, really speeding up the work.

API. Intermediate levels have deep and solid knowledge of the main APIs.

Frameworks. Middles are tech-savvy with frameworks which helps them write clearer and shorter code.

Database development. Mid-levels are good at managing databases. They can design normalized DB schemas while taking into account the queries that will be issued. Middle devs are well-versed in using database views, stored procedures, triggers, and user-defined data types (UDT). They are adept in the object-relational mapping technique (ORM) used for converting data between incompatible type systems. In order to speed up the query process, they apply knowledge of index syntax to create custom clustered and non-clustered indexes.

Programming languages. A mid-level developer understands functional programming and knows when and how to apply functional concepts in any language.

Platforms and tools. Middles have already worked with more than four platforms and possess a deep understanding of how the platform functions including code execution. They are very comfortable with their package manager tools.

Day-to-day duties. Mid-level software engineers are not commonly entrusted with highly complicated tasks that may require an in-depth level of engineering knowledge. Meanwhile, they may be tasked with designing a piece of the application to be prepared for the further transition to a senior developer. They are already capable of turning tickets into solutions, providing estimates on tasks, and assisting in decomposing larger sections of work.

Middle teamwork and perspective

Independent work. Mid-levels can deliver work with less supervision while being assigned to relatively routine tasks.

Teamwork. Middles actively collaborate with team members, including designers, business analysts, and architects.

Vision. Middle developers have deepened their understanding of development cycle scenarios which allows them to practice Agile methods more accurately. They see the results of the occurring problems and learn how to avoid them in the future.

Dunning-Kruger effect

A lot of mid-level devs fall under the Dunning-Kruger effect, which hampers their further career growth.  This psychological phenomenon describes what a dangerous thing a little knowledge can actually be. Being self-assured, developers may tend to overestimate their skills, which impedes their progress. That said, this condition is a big concern in software development. While this cognitive bias can happen to workers on every seniority level, mids are most vulnerable to it.

As a matter of fact, many engineers cannot picture better methods and practices than the ones they are currently implementing. Programmers that have had a string of unsuccessful projects may yield to the belief that it is usual for a project to be a nightmare.

In the opposite scenario, at some point software engineers may realize how little they know and how much is out there to learn. That is when programmers begin transitioning towards a higher level of seniority.

Dunning-Kruger effect on developers depending on their seniority and knowledge

Graphical illustration of the Dunning-Kruger effect on developers depending on their seniority and knowledge. Image source: Junior developers: you’re not a junior anymore, Amando Abreu

To reduce the impact of inaccurate self-assessment on skill acquisition, and overall career growth, developers should constantly work on improving their competency level by expanding their knowledge domain and gathering feedback from different parts of a business. They should always find time to reflect on their progress and draw the right conclusions.

Senior Developer: problem-solver

Developers with deep specialized knowledge and exhaustive experience that allow them to mentor their peers are titled Seniors. In addition, senior devs are also knowledgeable in the business domain they support. Their competency may even expand to help with marketing and overall business development. A senior developer will always think of what they are doing in terms of how much benefit it brings to the business.

In a nutshell, their job is to provide the best solutions to problems. Actually, a senior is trying to foresee the issue and resolve it before it happens. As a problem-solver, a senior must think in advance about the system bottlenecks, and keep in mind vulnerabilities and problems caused by the improper use of tools.

While leading a project, a senior makes well-reasoned decisions about software design and implementation based on the knowledge of the best practices in the field.

Alternative approaches. According to the Dreyfus model, seniority can be divided into two stages: Proficient (junior expert) and Expert.

Proficient programmers make a major breakthrough — they are able to reflect on their work performance, analyze mistakes, and learn from them drawing the right conclusions. By taking advantage of reflection and feedback, proficient devs significantly improve their performance. Such an approach is the core to Agile project management.

Now developers know that context is the key to becoming an expert. Therefore, instead of sticking to the rules, they implement various methods adjusting them to a certain context.

Expert is the highest rank in the Dreyfus model. According to Andy Hunt, one can get there through over 10 years of hard determined practice. Therefore, experts are a rare species. These senior developers have transformed their expertise into intuition.

Experts intuit best practices from their broad range of experience with different roles, technologies, and situations.

In terms of the seven software engineering expertise stages, this level has two of them: Master and Researcher.

Master is an adept technician and a good instructor that has a profound methodological foundation. More importantly, this developer understands the business value behind the product.

Researcher is a senior developer who is shifting from a specific project towards general methodological research. Researchers track down flaws in software engineering techniques to improve them. They also seek new problems to find the technique that is useful in solving them.

Senior technical skillset and duties

Having high technical skills, a senior developer is comfortable with multiple technologies. Seniors should be aiming at acquiring transferable knowledge that will allow them to recognize and write good code in any programming language. This knowledge also helps adapt to constant technical changes.

IDE.  A seniors’ expertise allows them to write custom macros to optimize the workflow.

API. A senior has written libraries to add more functionality or to automate the most frequent processes without having to write code for them.

Frameworks. Seniors have enough knowledge to build their own custom framework.

Database development. A senior is well-versed in database administration, performance, and index optimization. Usually, they do the delicate work of composing advanced select queries. Since seniors know a given database structure from the inside, they are familiar with the DB maintenance features, in particular, DB mirroring and DB replication. These are the methods of transferring data from a primary to a secondary database. Seniors understand the two-phase commit algorithm (2PC) applied for coordinating a distributed transaction (commit/abort). They can replace slow cursor-based operations with much more efficient JOIN statements, where possible.

Programming languages. Besides functional programming and OOP, they work with concurrent and logic languages, e.g. Erlang and Prolog respectively.

Platforms & tools. Seniors have had professional experience with more than 6 platforms. They are already creating debuggers or other tools necessary to enhance the platform. Seniors are the source advice on platform internals.

Day-to-day duties. The multifaceted responsibilities expand far beyond coding. Seniors brainstorm the right technological solutions to complex problems. They take charge of the team, coordinating its workflow to consistently produce business value.

Senior teamwork and perspective

Independent work. A senior is the one providing guidance.

Seniors put the team first and are always trying to figure out what they can do to help the members. They have good soft skills while balancing between the client and the team.

Vision. Seniors see the final goal — the problems that the finished application must solve. A long-term vision is a crucial point in bringing value to the end-user.

Competencies of developer seniority levels

Competencies of developer seniority levels

What comes after senior developer?

Senior developer is a good jumping off point for another rung on the ladder. Some seniors want to move into more technical roles, others prefer management roles. Here are some options a senior may consider transferring into.

Architect. This is the highest rank on the technical career ladder. An architect's job is to design complex systems that will be implemented by teams of senior and junior developers. Depending on the focus of the business problem, there are enterprise, technical, and solution architects. You may read more on it in our dedicated article.

Product Manager. A product manager with coding experience will feel more comfortable in leading the product delivery. Knowing the development process from the inside, they will be able to manage the work on the product much more efficiently.

Senior Leader. The work of a senior leader has little to do with programming and is all about people skills: inspiring, motivating, leading, and strategizing. When making high-level decisions that determine a company’s direction, a senior leader makes sure that all employees follow these decisions and believe in the mission.

External conditions that influence the qualification levels

While defining a developer’s seniority level, it’s important to consider the following variable factors that substantially influence the gradation.

Tech stack. One can be an expert when it comes to machine learning, but stay intermediate in web development. At the same time, a developer can even turn out to be a junior in many other areas.

Project. A project can scale both horizontally, and vertically, which entails different sets of skills and expertise.

Organization. The hiring organization’s characteristics should also be factored in. Consider the company’s size and individual requirements they set for a candidate. Smaller businesses usually look for specialists with broader skill-sets and responsibilities. For instance, an engineer in a smaller business can be responsible both for product development and deployment. A larger organization, by contrast, may need highly specialized expertise, like an engineer for a specific stage of the DevOps lifecycle that will work with a certain automation tool.

Moreover, each organization gives its own meaning to these terms. Thus, depending on the workplace, two senior programmers can be very different from each other. Robert Rees, a senior development manager on the digital development team of The Guardian newspaper, comments on that point: "When recruiting though we need to explain what a senior developer is, not just to ourselves, but to people outside the organization. Sometimes we also have the difficult job of explaining to people who currently have the title of “senior developer” why we don’t think they are a senior developer here at the Guardian."

Tips on picking a developer with the right expertise for your project

An important employment-related question is what expertise is required for this or that task. Hiring a developer can often get tedious if you only have an abstract idea of the competency level that can satisfy your project. Below are a few useful tips that will help you navigate through the hiring process to bring you the right choice.
  • Have a clear project goal and a basic understanding of the expertise level required to achieve it.
  • Consider the time and budget at your disposal. While a junior needs more time for training, a senior does not require much of a ramp-up and will start contributing right away. However, such an employee will be significantly more expensive.
  • Focus on team and organizational talent composition. Having a senior developer in a leadership role from day one is necessary to organize the workflow, as only a senior is fully qualified to select proper technologies and platforms for a project.
  • Stop hiring according to job titles. Having a title is different from having the skills and abilities to succeed in a job role. The experience one gathers on the way to becoming a senior developer matters much more than the acquired title. Therefore, to keep the existing roles meaningful, we have to resist job title inflation.


Sort by