From Junior Software Developer to Senior Engineer
May 8, 2020

Software Development

From Junior Software Developer to Senior Engineer: Developers Qualifications in Simple Words

By Olga Matuts

It is common practice to identify three levels of developer seniority that influence their salary and duties: junior software developer, middle, and senior. Such a distinction helps to build internal communication in the department and create the company’s expectations of software engineers.

But in the professional sphere, other approaches are also used to assess the level of experience of developers.

Let’s take a deeper look at how a developer’s career can progress, what to expect from an entry-level specialist, and how the requirements and duties change. 

What do experts say about software developer classification?

There are several approaches that give a more detailed classification and a more clear perspective for software engineers.

The Dreyfus model of skill acquisition 

Such a model includes 5 stages of skills acquiring: 

  • Novice
  • Advanced beginner
  • Competent
  • Proficient
  • Expert

Andy Hunt, in his book “Pragmatic Thinking and Learning: Refactor Your Wetware”, uses the Dreyfus model to show how developers perceive the development process: 

  • In the beginning, developers rely on rules rather than trust their intuition.
  • Newbies consider everything. As they grow to experts, they develop a relevant focus.
  • Novices are detached observers, and as time goes, they become a part of the team.

The seven stages of expertise in software engineering

Meilir Page-Jones created this classification, and, at first, it was used for the assessment of software engineering. Such an approach is based on productivity and demonstrates 7 expertise levels:

  1. Innocent
  2. Expose
  3. Apprentice
  4. Practitioner
  5. Journeyman
  6. Master
  7. Researcher

Programmer competency matrix

The author of this matrix is Sijin Joseph, tech leader, experienced in creating software products. This approach, in addition to a well-known junior, a middle, and a senior, includes a zero level for the trainee.  

To summarize these classifications, let’s compare their developers’ levels:

Programmer competency matrix The Dreyfus model The seven stages of expertise
Trainee Innocent
Expose
Apprentice
Junior Novice Practitioner
Advanced beginner
Middle Competent Journeyman
Senior Proficient Master
Expert Researcher

Let’s consider the differences in skills and workflows of these levels of developers.

Trainee

A lot of companies have special internship programs and invite entry-level engineers without working experience (with only theoretical knowledge). In this case, the beginner will be called a trainee.

If we look at the Meilir Page-Jones classification, the innocent are almost not involved in real development, the expose begin to work with professional code, and the apprentice feels more or less prepared for work with a real project.

If we speak about technical knowledge, trainees use IDE as a text editor for coding without their additional features. They almost don’t work with API and deal with only one platform. Trainees don’t figure out any frameworks and can’t answer the question about the database.

Junior software developer

Companies generally hire a junior software engineer for short-term contracts or freelance to decrease the costs of the project.

Junior developers are motivated and full of energy, as opposed to more experienced professionals; they try hard to grow to middle and senior developers. 

In the Meilir Page-Jones classification, a junior developer, named as a practitioner, gets practice, learns new methods and features and implements them in corporate projects. The productivity of the practitioner is increasing.

If we turn to the Dreyfus model, there are two kinds of junior developers: novice and advanced beginner. 

  • Novices seek quick results and get lost in mistakes. They don’t know how to avoid errors. Such developers need universal context-free rules.
  • Advanced beginners try to avoid fixed rules and learn to draw conclusions based on the knowledge achieved in similar cases. Still, they can’t see the larger context.

Junior developer skills and requirements

IDE. Juniors effectively work in IDE. They can orient in its interface and taskbar.

API. They are well-versed in API, which they frequently use. 

Frameworks. Juniors know about the most popular frameworks for their tech stack and have experience in the usage of some of them.

Database development. Juniors know common methods for database development, ACID properties, and transactions. They can write simple instructions for data extracting from the database.

Programming language. They can use one programming language and build a suitable solution that solves a large part of the problems in certain cases.

Platforms and tools. Generally, beginners demonstrate their experience in three platforms. They are not so good at orienting internal features of the platforms and know several alternatives to popular tools.

Usual duties. They deal with the easiest tasks that don’t have a serious impact on the final project.

Independent work. Juniors need a supervisor to develop their skills. 

Teamwork. Junior developers should be engaged in teamwork to get more knowledge and practice.

Vision. Juniors are focused on coding and don’t see a common picture of the project.

Middle developer

Junior developers with more than 3 years of experience can claim to be middle engineers. A middle developer is the most frequent kind of specialist in software development, and they deliver the biggest part of routine code. 

According to the Dreyfus model, a middle developer is competent, can effectively deal with coding, debugging, and troubleshooting.

Competitive developers are smart and use their initiative, imagination, and common sense at work. They can train beginners and show their leadership qualities. Meanwhile, they still need more experience to prioritize projects’ tasks and analyze their mistakes. 

In the seven stages of the expertise matrix, middle developers meet journeymen; they should improve their skills and enhance their productivity.

Middle developer skills and requirements

IDE. Middle developers’ work with IDE becomes more convenient and advanced; they use helpful shortcut keys.

API. Middle developers demonstrate deep knowledge of standard API. 

Frameworks. They work well with frameworks and write clear code.

Database development. Middle developers show good results in database management and can build database schemes based on queries. They know the principles of object-relational technique and index syntax and can successfully implement this knowledge for different tasks. 

Programming language. Such a developer understands and uses the concepts of functional programming. 

Platforms and tools. Mid-level developers can work with more than 4 platforms and figure out their features, including their package manager tools.

Usual duties. Middle developers usually deal with standard, not so difficult tasks that don’t require deep engineering knowledge. They estimate tasks and help with the development of large projects. Mid-level engineers can build parts of an application and deliver it for a senior developer.

Independent work. They require less control than juniors and can deal with routine tasks.

Teamwork. They can collaborate with other team members, as well as designers, architects, and business analysts.

Vision. Middle developers show a deeper understanding of the Software Development Life Cycle; they can predict the consequences of their mistakes and try to avoid them.

The hidden danger for middle developers

A lot of middle developers can face the psychological phenomenon named the Dunning-Kruger effect, and it can hinder the growth of their career. Developers with this phenomenon tend to overestimate their skills and knowledge that leads to a lack of progress. So, it is a big problem in the software development sphere. This situation can happen with developers at any level, but it is especially common for middle engineers.

Also, developers can’t understand that there are other, better methods than they use. After several unsuccessful projects, developers can get the feeling that all projects are a nightmare. 

Developers should permanently increase their skills and make their knowledge deeper, learn something new, and analyze the feedback.

When software engineers realize how much there is to learn and how small their knowledge is, they can turn to the highest seniority level. 

Senior developer

Senior developers demonstrate great technical skills and experience to lead large projects and supervise beginners. Also, they are good-oriented in the related business sphere and can participate in marketing and overall business development. Senior developers are not code-oriented or project-oriented; they focus on business goals.

Senior developers provide the best solution for the project, remember about all problem areas of and try to predict all potential issues with improper work with tools. They also make decisions about the development and implementation of software according to their huge experience.

Using the Dreyfus mode, the position of a senior developer is represented with the proficient and the expert.

  • Proficient developers can learn from their mistakes and use the benefits of analysis and feedback. This skill helps developers to increase their performance and is the key to agile project management
  • Experts can perfectly orient in the common situation, adapt to the context, and use it in their goals. Andy Hunt says that expert developers are those who, for more than 10 years of practice, turned their experiences into intuition.

The matrix of seven stages of expertise also presents two levels of senior developer position: the master and the researcher. According to this approach, 

  • a master is a good instructor with a great methodological and technical base and a deep understanding of business goals.
  • a researcher searches for drawbacks in the software development tools and methods to replace them with more suitable ones.

Senior developer skills and requirements

Senior developers can effectively work with several technologies and try to recognize and use any programming language for good and clear coding. They also can orient in technical changes.

IDE. Senior developers can build macros to make workflows more effective.

API. The senior engineer created libraries to enhance the API features or automate the most frequently used processes without coding.

Frameworks. They can build personal frameworks using their knowledge.

Database development. They demonstrate deep knowledge of database structure, its maintenance features, for example, database mirroring, and replication. Senior developers can enhance database work and replace cursor-based operations with JOIN statements. 

Programming language. They can work both in the functional programming sphere and with concurrent and logic languages, for example, Erlang and Prolog.

Platforms and tools. Senior developers work in more than 6 platforms and can create some tools to improve their work. They demonstrate deep knowledge of platforms’ internals. 

Usual duties. Senior developers’ day-to-day tasks are multifaceted: they make decisions about solving problems and the team workflows to achieve business goals in the most suitable way. 

Independent work. The main part of the senior developer’s work is to provide guidance.

Teamwork. Senior developers demonstrate good soft skills and try to find a balance between customers and the team. They try to make their teammates’ work convenient and effective.

Vision. They see the future results and problems that their product will solve. Senior developers use their long-term vision that is especially valuable for customers.

Career perspective for a senior developer 

A senior developer isn’t a final stage of a developer’s career. The future stage depends on the skills and preferences of senior developers. They can choose a technical way or a management role. Let’s consider what a senior developer can choose.

  • Architect. An architect stays on the top of a technical career. Such specialists deal with the design of multifunctional systems that will be implemented by development teams. According to the tasks’ specifics and business goals, there are several kinds of architects: enterprise, technical, and solution architect.
  • Product manager. The product manager with the developer’s background can effectively manage the software engineering’ team and use the acquired knowledge about internal development processes. 
  • Senior leader. This position requires people skills, so a senior leader should inspire and motivate employees, lead them, and create effective strategies for the company’s growth. The main goal of a senior leader is to make sure that employees follow these goals.

Qualification level and external conditions

The qualification level of software developers also depends on several external conditions.

  • Tech stack. A developer can be an expert in a certain area, for example, machine learning and, at the same time, stay intermediate in different technologies.
  • Project. A project can be scalable both horizontally and vertically, so developers need several skill sets.
  • Organization. Different enterprises have different requirements to their specialists. For example, small companies usually need developers with wide sets of skills and responsibilities, and their engineers can deal with product development as well as its implementation. Large organizations require specialists with specific experience, say, with certain automation tools or particular stages of the SDLC.

So, two senior developers can significantly differ from each other. 

How to choose a proper developer for your project?

It is very important to make a choice about the qualification level of the developer before you hire the specialist. We prepared several tips to help you with your search.

  • You should understand the project’s goal and the scope of your tasks for a developer. Also, you need to realize what level of knowledge will suit your requirements. 
  • Take into account your project’s timing and budget. Junior developers need time for training, but their services will be less expensive. Senior developers can yield benefits right away, but it will cost more.
  • Think about your developers’ team structure. A senior developer plays a crucial role in the process organization: he or she has needed qualifications to choose the appropriate tech stack and strategy for development.
  • Understand that the job’s title is not the point. The job’s title is not as important as a specialist’s skills and experience.

We hope that our post will help you to better orient in the software developers’ world, and you will be able to find the needed specialists for your project. 

Leave a Comment

We use cookies to personalize our service and to improve your experience on the website and its subdomains. We also use this information for analytics.

Got it!