7 reasons why software developers fail due to company’s mistakes

It’s been estimated that almost 50% of newly hired employees fail in their jobs within the first 2 years and the first 3 months are the most crucial for their success. As I discussed in my previous post there are various reasons why newbies fail. Is it only dependent on their own behavior or attitude? Is it only down to the internal reasons? What about the external factors such as the impact of the company they start working for?

The personal reasons for failure seem to be obvious:

• Newbies don’t accept feedback and don’t listen to more experienced colleagues
• They are too self-confident and immune to criticism
• They seldom ask for help and support, prefer to struggle on their own
• They report issues and blockers when it’s too late to request for more hours and a new budget
• They play independently and don’t work towards a team goal
• They don’t socialize within the company thus are unable to become a part of the team

Cearly all the above fall into one category: social skills and communication. This is the key to success in a developer’s job. However, there are other reasons responsible for their failure that are beyond their control.

1. Lack of proper Induction Process

It’s very essential to provide the newly hired with all basic information to make them feel comfortable in a new workplace. Once they feel settled they get more productive in a shorter time. The impression of being completely lost in the beginning doesn’t create the sense of security in na newbie and the positive attitude towards the company. New employee’s first days/weeks have a strong impact on the long-term job satisfaction.

2. Lack of a “buddy” figure

A fresh graduate from the IT department who only starts their first job has no idea how to handle certain issues, whom to go with certain problems etc. It also creates a sense of insecurity. The senior employee appointed to be a “mentor”or “buddy” should also be responsible for setting long time goals for self growth together with the newbie. He must know what is expected of him, what he wants to achieve and what his desired career path is. How can you monitor and stimulate the growth without this knowledge?

3. Mentor is not focused on the newcomer’s personal growth

Mentors sometimes don’t take their role seriously enough and skip evaluation meetings and don’t do regular code reviews. How can a beginner developer learn if he doesn’t know his mistakes? If we let bad practices turn into regular habits it’s hard to eradicate them later. Can we actually blame an inexperienced employee for our lack of proper reviews which aim is to make sure he follows the adopted standards.

4. Newbie is assigned to several different tasks

Fresh coders usually are not confident enough in multitasking. Once they are settled it goes more smoothly but usually problems appear when they have no possibility to focus on one technology/solution. They have problems with priorities and get easily distracted. Maybe we should let them master one skill at a a time?

5. That’s not the job the company advertised

Sometimes, due to various reasons, the company decides to give slightly different responsibilities, or add new tasks that are not according to the initial agreement or a job description. The explanations vary: “after one day we already know he won’t manage so let’s move him to other projects and then we can think what to do with him”, “we are short of resources in this project and the deadline is close so let’s use him temporarily here” (which by the way usually drags for weeks). Eventually, newbie gets annoyed and unmotivated since it’s not what he has been dreaming of.

6. Too many juniors in one team

It’s risky when the company hires too many newbies and get them to work together in a new team. In such environment they may support each other and feel the bond because of being “new on the block” but the don’t learn from more senior guys. The should always be a proper balance of force in every team to stimulate growth. Too many inexperienced coders in one team may become lost like children in the fog.

7. Junior developers get too difficult tasks

It happens that they are assigned to really complex tasks since we really don’t know what they are capable of. The tasks are underestimated because seniors who decide how much it’ll take estimate according to their own criteria and skills. They don’t do it on purpose. They are often unaware of this and do it automatically. For them a task that they have done millions of times may be a piece of cake, for a junior it may be easy as well but he needs time to figure out the approach and the way he will handle the task. Thinking is time-consuming.

Probably you recognize this, at least we do

Does the above sound familiar? We’ve seen it and experienced it, so now, after 3 years, we can say we know how it works. We keep on trying to find the most effective solutions and stick with them.  Some prove to be very successful and some turn out to be complete failures. But that’s what  allows us to keep learning and growing.  And often the only way to truly grow is to learn through your own failures.

I guess it’s essential to provide a proper induction program and really take care of these juniors from the very beginning. They should also see our commitment to their growth. If we avoid these mistakes we reduce the number of early leavers, and then the cost of replacement, new recruitment campaign etc. Such staff rotation also kills the atmosphere inside the company and the team spirit. I think it’s really worth investing in what you’ve got and actually “build” a healthy team. We can’t forget that, after all, the juniors of today may become our best seniors after some years.

Maciej, thank you for your contribution into to this post!

What mistakes have you or your company made with new people? Why do newbies fail? Feel free to leave the comments below and follow us on Twitter on @GOYELLO.