Tips for mentoring Junior-Level Developers

Hiring junior-level talents has always been a challenge. It is no coincidence that many software academies have appeared to try and ease the hiring process of beginner-level developers. However, it is always the company's responsibility to bring their new colleagues into their culture, processes, and conventions.

In that regard, we are happy to have developed an excellent mentoring system that has proven effective and gained positive feedback from the trainees.

I will share the main points of focus for the duration of our mentoring program.

Time frame

The time needed depends on the experience level of the trainee. Generally, 3 to 6 months is the standard period for a young colleague to reach a competent skill and confidence level to participate in larger tasks as part of a team.

Points of focus

We have divided our mentoring program into four main parts that develop problem-solving skills and simulate real work experience. In the end, it is expected that we cover the following aspects: 

• Going through the software development cycles

• Working comfortably with git

• Following code conventions and simple code practices

• Dealing with unexpected requirement challenges

With that in mind, here are the four main focus points:

1. Solve algorithmic problems and go through a pre-selected course

Depending on the level of experience of the colleague, this part could take from a couple of weeks to more than a month. The main idea is to practice problem-solving skills in a particular language and get familiar with git and the command-line interface. 

2. Solve a non-trivial algorithmic problem

This phase is pivotal in our mentoring program. We pick a more significant task involving working with a more complicated data structure, for example, a graph. During this task, the trainee must also implement a custom variation of standard algorithms like depth-first or breadth-first search. 

By the end of this phase, we have a working console application and are ready to move into a more real-world setting. It usually takes up to a month to reach this point.

3. "Apify" our console application

This is where we introduce a more structured approach to software development. We attempt to simulate an actual project setup and present common challenges in that scenario.

The goal is for the trainee to expand their API development knowledge with a concrete tech stack. To help with that, we provide courses as an additional resource, but we prefer hands-on experience, so we give out an initial API project structure that needs to be followed down the line. 

The first task we set is integrating our previous console application into the RESTful API project. This provides a good challenge for less experienced developers because they need to shift their way of thinking in the context of HTTP communication. They start to handle aspects such as: 

• parameter validation

• state management

• HTTP methods

• CORS

After that, we expand our project with additional features that introduce working with databases, authentication, and authorization.

An important notice here is that the new developer gets introduced to an ORM framework at a later stage, so they can realize and better understand the benefit it provides.

Another critical approach we use is to simulate requirement changes. So once the developer is done with the main API features, we plan a new set of features that require some refactoring. This is a good practice for the real world, where clients often have second thoughts, demonstrating the value of keeping a clean code convention.

We often dedicate a long time to this phase of our mentoring program as it creates a reasonable basis for work habits and introduces feature planning and code review processes.

4. Work on an internal project or build a front-end solution

At this point, our young colleague is ready to take on more responsibilities in a team. Depending on their interests, the trainee could take on a role on an internal company project as a back-end developer or work on his front-end skills. 

Our front-end phase is quite similar to the API development phase described above. It directly consumes the REST endpoints and focuses on the React tech stack. The main points of focus include: 

• CRUD cycles

• React state management (redux and hooks)

• Front-end validation and response management

• Authentication handling

Conclusion

So far, we have multiple colleagues who underwent our mentoring program and successfully joined some of our teams. Judging by our experience, it is essential to offer a challenge and bring it close enough to the real-world application to keep the trainee’s interest and involvement. We know the necessity of practicing problem-solving skills, but we also learned to integrate them into a bigger-scale learning project, and with the feedback and success we have gotten so far, it seems we have found the right strategy.