I would share my thoughts on the process of mentoring and evaluating developers. As a tech lead, I’m trying to assist developers in their learning and improvement process. Also, it is commonly required by the company to evaluate them and define some goals.

In the first part, I have described my expectation from different levels of developers. I wouldn’t suggest treating them as requirements for that level. For me, it is rather a set of markers showing that the person is performing well on their level.

While I occasionally use these tables to assess developers, determining one’s level is often complex. Factors such as company and project expectations and an individual’s ability to effectively communicate their knowledge and skills can significantly influence the assessment. Furthermore, it is essential to consider each developer’s unique strengths, experiences, and growth potential when evaluating their level. One should also recognize that performance may vary depending on the project or team dynamics. Therefore, it is crucial to approach assessments with a holistic perspective, considering the nuances of each situation and the evolving nature of a developer’s skills and knowledge.

So that description isn’t some ultimate grade system but just a tool to start analysis and maybe to find some areas for growth.

In the second part, I describe my use case of building a learning roadmap for the developers using that expectation and understanding of the project requirements.

Levels

I will use the following grade system:

1. Intern - a person who starts working as a developer and participates in the project for an evaluation period (in my practice, it is usually for three months but may vary).
2. Junior - a person who usually works for the first years as a developer, sometimes just a person who doesn’t particularly interested in their level of improvement and plays a passive role in development.
3. Middle / Pro - regular developer, usually already have 2-3 years of experience.
4. Senior - developer that will play a significant role in the project, usually already has 4-5 years of experience.
5. Tech Lead / Expert - someone who can drive the project and understand advanced topics.

Markers

Let’s intend the next group of markers:

1. Work style
   1. Independent work
   2. Cooperation with team members
   3. Cooperation with other teams
2. Technical knowledge
   1. Basic stack (for example, Java, Spring, JPA, SQL)
   2. Additional stack (for example, NoSQL, messaging, distributed systems)
   3. Advanced topics (for example, concurrency, transactions, consistency, streaming & reactive programming, and events)
   4. Quality (code quality and testing)
3. Problem Solving & Decision-Making
   1. Understanding
   2. Decision-making
   3. Problem-solving and troubleshooting
4. Leadership & Mentorship
   1. Project Management & Leadership
   2. Mentoring & Knowledge sharing

I should explain technical knowledge because it depends on the project. Ideally, we need a map for the project stack to define the technologies the developer needs. Here are two examples of how it could look like.

Some technologies will refer to the typical tasks of the developer. For Java developer, it seems to be Java, Spring and technologies related to the project database. The additional stack will refer to some extra activities or non-trivial tasks. It could be technologies related to DevOps, testing, or frontend if they occur in the developer’s work.

Another essential aspect is independence and the right to make mistakes. I have used the terms “independent work” and “optimal solution”, but it doesn’t mean developers should know everything and never make mistakes.

Independence of work is rather metric that the tech lead or somebody else in the team shouldn’t supervise that developer on a daily basis. For me, an independent developer is a person who is able to organize their work to achieve project goals.

Regarding optimal solution, it is making a meaningful decision, understanding limitations,s and gettering requirements—organization of cooperation with other developers to choose a better solution.

When we understand what could be helpful for the developer in the project scope, we may try to build their map for improvement. I believe it should be some personalized view containing technologies from the current project and any topic that person wants to learn. For less experienced developers, it could be crucial to reduce the project’s initial scope to focus on the essential parts. Here is an example of a map for a junior developer in the first project.

Work Style

	Independent work	Cooperation with team members	Cooperation with other teams
Intern	Works with constant control of the supervisor.	May focus on communication with the supervisor.
Junior	Works with regular supervision; otherwise, it may cause that task to be unfinished.Typically focuses on straightforward tasks with a reference implementation in the existing codebase.	Openly communicates with all team members. Able to ask for help when needed.
Middle	Works independently, and supervisor control is required to ensure an optimal solution.		Сan represent the team, involving other teammates when needed.
Senior	Works independently and can involve other people to produce an optimal solution. Can drive particular streams inside the project, like migrations, new components, and deployment.	Can supervise work on particular topics and tasks.	Can arrange communication with other teams in the scope of the particular topic.
Expert	Works independently and usually produces an optimal solution.	Can supervise work on projects and components.	Сan arrange communication with other teams.

Technical Knowledge

	Basic stack	Additional stack	Advanced topics	Quality
Intern	Familiar with Java and a basic understanding of Spring, JPA, and SQL.
Junior	Proficiency in Java, Spring, JPA, and SQL allows for implementing regular features.			Capable of developing while adhering to code standards and testing practices, using existing project code as a reference.
Middle	Proficiency in Java, Spring, JPA, and SQL allows for implementing complex features.	A basic understanding of Messaging and NoSQL allows for implementing simple features.	Basic understanding of advanced topics.
Senior		Proficiency in Messaging and NoSQL allows for implementing regular features.	Understands and can implement advanced concepts with guidance.	Ensures code is efficient, maintainable, and adheres to quality and testing best practices.
Expert	Expert in Java, Spring, JPA, and SQL, can design and optimize complex systems.	Expert in NoSQL and messaging can architect systems using these technologies.	Deep understanding of advanced topics, can design and implement solutions based on them.	Sets and enforces coding standards and best practices for quality and testing across the organization.

Problem Solving & Decision Making

	Understanding	Decision-making	Problem-solving and troubleshooting
Intern			Able to look for information when met with difficulties.
Junior		Participate in order to understand decisions.	Can solve simple problems, needs guidance for complex issues.
Middle	Understands the project design. Can explain the major decisions that were made.	Participate and suggest solutions.	Can solve most problems with minimal assistance, proficient in troubleshooting.
Senior	Understands the project design, current limitations, and requirements. Can explain the decisions that were made.	Actively participates in the decision-making process, arguing limitations and requirements. May need help to cover all options and limitations.	Solves complex problems and helps with troubleshooting for other teammates.
Expert		Can make decisions or arrange a decision-making process. As a result, he provides a sufficient description of available options, requirements, and limitations related to the decision.	Solves complex problems and suggests troubleshooting processes.

Leadership & Mentorship

	Project Management & Leadership	Mentoring & Knowledge sharing
Intern
Junior
Middle	Contributes to project planning and may coordinate work on tasks.	Mentors junior developers and can share knowledge across the team.
Senior	Actively contributes to project planning and may coordinate work on components and projects.	Actively mentors junior and middle developers; actively share knowledge across the team.
Expert	Able to arrange team approach to project management estimation and cooperation among team members.	Actively mentors all levels of developers and promotes a culture of learning and continuous improvement.

Use Case

Assume Tech Lead wants to evaluate the developer and define a vector of his/her self-improvement. Lead may prepare an evaluation in the table that looks like this:

Please note that marks refer to the levels where 1 is an intern and 5 is an expert.

The objective should be to identify areas for growth and establish goals for the developer. Engaging in a discussion to determine whether the developer and the lead share the same perspective on their level can be beneficial. If there is a discrepancy in the assessment, setting a goal to enhance visibility may be a good approach.

Additionally, I utilize two markers:

• “Good in” marker: This should be suggested by the lead to indicate areas where the developer already excels and may not require as much focus for growth.
• “Interest in” marker: The developer should determine this to highlight aspects they wish to improve.

Then assume we already have the project map and want to add the same marks.

Finally, the last step is to use that two inputs and build a personal map. Please note that it shouldn’t fully match the project map or lead expectation. The developer is responsible for creating his own learning and improvement roadmap.

As a result, we have a roadmap for developers that could be a powerful tool for mentoring. We may share our expectations with the developers and use them for their evaluation. Meeting with developers helped us to build a shared understanding of the expectations and the importance of knowledge used in the project.