The acquisition of qualified IT workers is becoming increasingly challenging – salaries and expectations are rising sky-high, making skilled workers difficult to hire in a market that is already struggling with supply. While more and more companies put their emphasis on improving their developer relations, Virtual Minds has decided to adopt a slower, but more long-term oriented approach: educating our own engineers.
This approach has already found broad adoption in Central Europe: If you need experts, train them yourself. Germany in particular, is known for offering a wide array of well established trainee programs that cover most fields of work. Some of these programs replace college education while others – e.g. software-development in our case – exist in parallel with it. Usually a traineeship takes three years, in which the trainee is hired by a company where they work, while also attending a specialized school on a regular basis. This approach aims to instill both practical and theoretical aspects of the field – the theoretical aspect being covered mainly by school, while practical skills are acquired through mentorship by senior employees.
In Germany, traineeships are the favoured approach in multiple fields of industry, and we have had great results applying it to both software development and other engineering jobs. In fact, at one of our subsidiaries, Active Agent, every team lead position is currently filled by someone who started out at the company as a trainee. They now have the responsibility to lead the training of new developers.
We believe the key to Active Agent’s success in training qualified developers can be narrowed down to the following key factors:
- constant feedback.
Active Agent’s traineeship program has been refined by over ten years of experience, during which over fifteen developers have been trained.
Many developers work and succeed in the industry because of their fascination with technology and the possibilities that follow hand-in-hand with it. Challenge is a very important tool to ignite that fascination in your trainees, in order to help them reach their full potential and support them in becoming skilled developers.
In the beginning, our trainees spent the first few months doing “unloved” developer duties like cleaning up code, writing small unit tests for old components and other rather repetitive tasks. While this helps getting familiar with a project, it has some severe drawbacks. Not only does it get boring to do mostly repetitive work, it also does not stimulate creativity in the trainee enough. Additionally, writing proper unit tests requires a knowledge of the system you are testing, which cannot be expected of new trainees. This leads to a degradation in test quality. Thus, while unit tests are a vital part of the system’s integrity and the development process, it was difficult to give our trainees the feeling of appreciation for their work.
Subsequently, we decided to let trainees start off by working on the main projects, much like freshly hired junior developers. This turned out to be pretty overwhelming for most of the them and put a huge overhead on the team because every line of code produced had to be extensively reviewed.
To tackle these problems while keeping the advantages, we now have all trainees working on larger projects together. These projects usually run in parallel to our own systems, allowing for both a deeper understanding of their future work environment, as well as the possibility of finding creative solutions for unique challenges. In order to get to know a lot of different technologies, we always aim for projects that require a full stack developer. Furthermore, we try to intervene as little as possible in their development process, intentionally allowing mistakes to occur, from which they can learn.
With this strategy, we managed to create an environment where trainees face a lot of different challenges that naturally occur during software development and can hone their skills that would not have been acquired from only working on small, repetitive tasks.
In order to become a good engineer one must not only be able to write good code but also work together with other people like colleagues and product management, as well as satisfy requirements for features. In order to do this, one needs to take responsibility for writing proper code, pushing reasonable git commits, adding important customer features, meeting deadlines and communicating early if deadlines cannot be met.
When we started with the projects, we used to let trainees write throwaway projects that they locally developed on their machine. The motivation behind using throwaway projects was that the projects themselves did not need to be perfect. However, this decision did not help foster any of the aforementioned important soft skills. We also knew from previous experiences that we did not want trainees to develop projects with direct customer contact, as it would mean, again, that the team had to be very closely involved in the planning and verification of the project.
Like most companies, we have a lot of good ideas on what would make the lives of the development or support team easier, but implementing those ideas would take too much time to develop, so for us it felt only natural to turn those ideas into projects and let the trainees work on them. Our product management collects requirements for the projects and organizes them in a scrumlike environment, which helps preparing the trainees to work as a normal developer in the teams. Most of these projects are still in daily use and are being further developed to date, which does not only help our team work more efficiently, but also gives the trainees a great feeling of appreciation because their work is actually used on a daily basis and they get frequent feedback for it.
We strongly believe that this way we can foster all necessary soft skills apart from writing code; a win-win situation where we not only get good developers out of the equation but also end up with really useful tools that improve our daily lives and make us work more efficiently. Furthermore, it’s also a very good environment for new product managers to get into the team and our workflow.
The last point we believe as absolutely vital is constant feedback.
Our understanding of “providing feedback” is not limited to a senior supervising their apprentice by telling them how they could improve their code in certain aspects, but it’s also about having someone you can discuss your ideas with, even at very early stages of development. Obviously it takes a tremendous amount of time to provide this kind of feedback, which often ends up, in two rather unfortunate situations: either you have to almost exclusively dedicate one of your senior developers to supervise the trainee or the trainee has no one to talk to as the senior developer is currently busy, which not only leads to a lot of downtime for the trainee but can also be discouraging.
We tackled this problem by making sure we hire at least two trainees in the same year, which are then supervised by one senior developer. This way the trainees can work together on projects, learn how to properly use git, how to work with other members of a team, verify each other’s code, as well as discussing their ideas with each other. The senior developer is regularly checking in on how the projects are going and is contacted as soon as the trainees are struggling to find solutions on their own.
In our experience, this model creates an environment that promotes discussion while training multiple developers at the same time and alleviates pressure on the senior developers. We noticed that up to a certain point it is actually less work to supervise a larger number of trainees, resulting in our current trainee team having four members while still being supervised by one senior developer. It is also a very good soil for the senior developer to develop skills to lead a team and can greatly help in taking responsibility for full teams in the future.
Another point that is really important, is the personal development of the trainees. In Germany they usually start their traineeship somewhere between 16-20 years of age, which is obviously still rather young. We tackled that issue by assigning each trainee a mentor that guides him through the three years of the traineeship by providing frequent feedback on their personal development.
We are confident that we found a solution that works favourable for both the supervising senior developer, as well as the trainees to provide adequate feedback in the entire time of the traineeship.
To sum up, we believe a good setup for a traineeship should fulfill the following checklist:
- Provide projects that challenge trainees without overwhelming them
- Choose projects that are used and appreciated by others
- Let trainees learn from their mistakes and don’t intervene too much
- Encourage the trainee to take responsibility for their code
- Hone the soft skills of trainees by creating an environment where they are not isolated
- Hire multiple trainees or at least make sure to dedicate enough time to provide proper feedback
- Nurture personal development of trainees
The last few years indicate that we are on the right track – the majority of traineeship graduates have stayed loyal to the company for 5 years or more. Having company specific know-how and being more involved in the company makes them valuable assets to all of our development teams. Together with colleagues from universities or abroad they provide strong synergy of theoretical and practical approaches to problems and can greatly benefit from each other.
As we’ve had a good experience in Freiburg, we are beginning to roll out this model to Hamburg and Berlin, our other development locations. This approach is driven by the understanding, that the business we are running is valuable to our customers for a longer period of time. Long-term thinking is one of the key ingredients to make such a program happen. If you want to know more or share your opinions and experiences feel free to contact us. We have not yet had the opportunity to train a PO of our own, but it is something we are looking forward to.