The global IT industry employs millions of developers with a wide range of experiences and skills. To differentiate between more experienced and skilled specialists from those who are less so, the industry uses the terms junior, middle, and senior.
Each company has its own vision of the engineering grades. Smaller companies tend to have less defined levels, and position titles may be determined solely by the company's CTO. Even within the same company, specialists with similar experiences and skills may have different job titles. Large corporations with tens of thousands of employees usually have big (8-10) number of different grades, that solve plenty of tasks, not just the employee's competence distinction.
Unfortunately, these levels often don't accurately reflect the reality. It's not uncommon for a senior engineer from a smaller company to be interviewed at a FAANG-level company and be offered a middle or even junior developer position.
This situation is more or less harmless for the experienced engineers and hiring managers, but it can be really confusing for the junior specialists. It's unclear which competencies should be improved and which goals should be aimed in order to climb on this engineering ladder.
Despite the variety of companies, methods and opinions, it's possible to point out some basic grades in engineering ladder and show the differences between them. Here's the review of the most common industry grades for a software engineer (individual contributor) role:
- intern SE
- junior SE
- middle SE
- senior SE
- lead / staff SE
Management positions (engineering manager, director of engineering, VP of engineering, CTO), their competence set and career track is out of the scope of this document.
Basic technical knowledge necessary for the job. For example, knowledge of a programming language (Java/Python/JavaScript/C++), ability to work with version control systems (Git, SVN), OOP principles and design patterns, basics of working with databases, understanding of operating system principles, computer networks, client-server applications.
Interns are not expected to have perfect knowledge in each of these areas, but a basic understanding of the above will make the job easier at first.
Interns solve easy tasks from the team's backlog. Before starting work on a task, they talk to a mentor — to verify the understanding of a problem and the proposed solution. Interns independently seek answers to emerging questions, but turn to a mentor if they come to a standstill. Interns try to complete tasks on time and report their problems in a timely manner.
Interns study the best practices of development, code review, testing, ci/cd. They get acquainted with the processes of the company and learn to work in a team. They actively study new technologies and dive deeper into the fundamentals. Interns build a development plan with the help of their mentor.
The same set of skills as described in the intern section. The main difference is that juniors have some practical experience with many of the areas. Also, they may have wider and deeper theoretical knowledge, since they already have some hands-on experience.
Juniors solve easy and medium tasks and bugs from the team's backlog with a low degree of uncertainty. Usually work on stable parts of the codebase and perform small or medium changes. Rarely collaborate in development of new and raw components to avoid interfering with more experienced colleagues. When writing code, juniors try to foresee possible problems and avoid them. They consult with a mentor on new issues.
Juniors actively study the codebase of the projects they work on, learn patterns and techniques, try to track down the motivation that led to certain technical decisions. They participate in code review as a spectator and learn from more experienced colleagues. Juniors gain experience with programming languages, design patterns and other technologies with the help of technical examples in the project they work on.
Middle engineers have accumulated some wealth of technical expertise. They are confident with programming languages and frameworks, design patterns and development tools. In most cases they choose good solutions for the tasks they work on and don't need much supervision. Middle engineers have broad outlook in their area of expertise and also have some basic understanding of what is outside of it. They have hands-on experience with many development processes, so they don't have much trouble during the onboarding in a new company.
The experience they gained helps to avoid common problems and don't waste time on trivial mistakes. Middle engineers already have some intuition to anticipate risks, difficulties and pitfalls, so they could discuss the optimal solution with their manager in advance.
Middle engineers solve problems of average complexity and scale. They can implement a new module or component within the existing project architecture on their own. They know how to deal with emerging problems, search for the root causes and eliminate them. Middle engineers often conduct code reviews and helps junior colleagues. They work independently and consult with their mentor only in difficult situations.
Middle engineers know their strengths and weaknesses and have their own vision of the growth areas. They can ask help to choose the optimal directions though.
Senior engineers have deep knowledge in various fields and good understanding of fundamental concepts. That helps them to navigate through yet unknown technologies. They have a strong knowledge of one or more programming languages and hands-on experience of writing high-quality and structured code. Senior engineers have good understanding of design patterns, algorithms and data structures. They also know the basic concepts of building large scalable systems.
Senior engineers independently solve complex problems that have high levels of uncertainty. They communicate with customers to clarify requirements, identify risks and limitations. Senior engineers are able to design complex technical solutions and decompose them to smaller executable steps. They try to minimize risks and anticipated problems, make tradeoffs between the development speed and solution quality. They conduct a research when the available data is insufficient to make solid decisions. Senior engineers control the technical debt and are responsible for quality. If necessary, they mentor their less experienced colleagues. Senior engineers agree on the ultimate goal and the expected result with their manager and then proceed on their own.
Senior engineers can extend their knowledge by studying the implementation details of some popular technologies - data storages, message queues, file systems and network protocols. They can learn modern architectural approaches, the principles of building fault-tolerant distributed systems, highload and big data concepts. Senior engineers should work on improving their communication skills and cross-functional team work, including interaction with stakeholders, product managers, analysts, designers.
Staff engineers have expert knowledge and practical experience in many areas, and are able to quickly learn and apply new technologies. They can make complex technical decisions and choose the trade-offs, to guide the development of large projects or systems, to lead large technical changes across the entire company.
Staff engineers solve the most complex and large-scale problems. They are expected to be the technical leaders within their organization, and to have a broad perspective on the software development field, with the ability to influence both technical and business direction. If necessary, staff engineers can mentor senior engineers.
While staff engineers have already developed a high level of technical expertise, they may still have some room for expanding their knowledge. They can also improve and develop communication skills, people management and project management expertise.