TL;DR.
When talking about teams, it’s important that tasks are distributed fairly among people. That means taking into account experience and exposure to different circumstances. Having an openness to testing new things and learning, pretty much every novice can reach senior level. That is why, in a healthy software development team juniors should be given the opportunity to develop their skills by being involved in relevant projects and by solving tasks appropriate to their level of experience.
However, there are situations when a senior temporarily takes on certain tasks of a junior. Is it fair towards the senior? Is it fair towards the junior? What does this practice promote? This article tackles two concepts that might have been forgotten in recent years: ethics and loyalty. While the article does not give general solutions, it manages to present some perspectives and to open a debate around the practice.
Context
In general, it’s important that to do’s are distributed fairly and assigned based on the level of competence and experience of team members.
A software development team may include juniors, mid, seniors, principals; each role having its sweet and rough spots. For example, having a junior in the team means having someone rather malleable, someone in search of its own style and hungry to absorb information; the other side of this situation is that a junior developer requires lots of guidance, availability, proper context for development and lots of, well, patience.
Actually, when it comes to hiring juniors, different companies have different excuses:
- Startups: “we are a very small team and we don’t have time to mentor juniors, we need engineers who will be very productive from day 1”
- Medium-sized companies – “we are going to grow very fast, we need engineers who can handle scale and who have faced similar challenges before”
- Big companies – “our infrastructure is very complex, it’ll take juniors too long to ramp up”.
Putting excuses aside, there are also many companies who see value in juniors and who invest in them. And then reality hits and shows that at a given point in time, in a pretty particular set of circumstances, this occurs: the senior of the team has to do the work of a junior or juniors. That happens especially in situations where the project needs to be kept on track and when things need to happen fast.
We might say it’s not inherently unethical for a senior to occasionally do the work of juniors. However, there are potential ethical concerns if this becomes a regular practice. Speaking of ethics, we might be dealing here just with that, an ethical problem. But this becomes even more interesting when we talk about two areas of ethics: ethics towards colleagues and ethics towards the client/project.
What is it
How do these two gray areas look like:
- “Loyalty” towards the client/project looks like acting fast and maybe in a complex manner. When there are tight deadlines and critical tasks that need to be completed, a senior might take on some tasks to ensure timely delivery of the product. Also, some tasks may involve significant technical complexity or require advanced knowledge to be completed correctly. In such cases, a senior might step in to ensure the problem is properly addressed. Sometimes, a senior temporarily taking on some tasks can serve as a learning and mentoring opportunity for the junior. This can be beneficial for both the junior’s skill development and the project’s progress.
- “Loyalty” towards colleagues means addressing things as they are: “It is not ok for one person to do the job of others”. If a senior needs to intervene and do the job of the junior this could potentially set a dangerous precedent; one that could end up promoting incompetence, lack of interest and an overall work imbalance. The price to pay is just too high: growing resentment and frustration inside the team, a path to burnout for the person overloaded with multiple roles, disrupting established workflows and processes.
While flexibility and willingness to help are valuable traits, maintaining role clarity and ensuring each team member can focus on their designated tasks is essential for the overall health, efficiency and effectiveness of a software development team.
Why is it relevant
It’s essential for teams to strike a balance between providing learning opportunities for juniors and ensuring that seniors are appropriately utilized and respected.
For better understanding of the two roles, let’s quickly recap who’s who:
Generally, the profile of a junior developer looks something like this:
- Usually under 2.5 years of experience;
- Needs specific guidance;
- In addition to basic programming skills, a junior developer knows how to give and receive feedback, has the ability to express himself and has the availability to offer guidance to fellow colleagues;
Generally, the profile of a senior developer looks something like this:
- Usually around 5-7 years of experience;
- Self sustainable, offers guidance and mentorship;
- A track record of success leading teams and conquering complex projects;
- Proven ability to lead and client interaction abilities;
- When it comes to technical knowledge, a senior masters plenty of areas; he has the ability to design a set of processes and the ability to understand software at an architectural level; also, a senior has the ability to assess performance of other team members and to propose strategies for growth; also, he has the ability to assess complex technical solutions and to determine the pros and cons for the solutions.
As we can see, while it’s crucial to ensure that juniors have opportunities for growth and development, it’s equally important to recognize the value of the senior’s time, skills, and expertise. Otherwise this turns into a waste of talent, one of the biggest problems an organization can have.
Pro
Seniors have likely spent years honing their skills and gaining experience in their field. It may not be the most efficient use of their talents to consistently perform tasks that are well within the capabilities of junior team members. Fairness dictates that seniors should be able to focus on tasks that leverage their expertise and contribute to the overall success of the project.
On this note, here are some considerations regarding fairness to the senior:
- Workload balance: Consistently burdening seniors with tasks that should be handled by juniors can lead to frustration and a lack of enthusiasm. Fairness requires that workload distribution within the team is equitable, with each member contributing according to their abilities and experience level.
- Constant development: Just as juniors need opportunities for growth, so do seniors. Engaging in tasks that are challenging and require their expertise allows seniors to continue developing professionally and prevents stagnation in their careers.
- Erosion of trust: Trust is a foundational element of effective teams. If the unspoken rule inside the team becomes one that the senior will act as a savior, the trust will be broken.
Con
Here are some “soft” methods for holding juniors accountable:
- Constant feedback: Providing regular feedback to juniors on their performance, highlighting areas of strength and areas for improvement. Conducting formal performance reviews periodically to assess their progress and discuss opportunities for growth.
- Have the difficult conversations: No one wants to be the bearer of bad news. But dealing with problems as they arise means being uncomfortable in the short term so that things don’t go downhill in the long run. At this point, conversations about accountability, owning up to things and competence become mandatory.
Financial incentives or penalties may create unnecessary pressure and may not necessarily lead to improved performance or accountability among juniors.
Conclusion
Taking on the role of others within a software development team can indeed be framed as an ethical issue, as seen. Most of all, it is important to avoid setting a precedent inside the organization; when team members take on others’ roles, it sets a precedent that can influence the broader organizational culture, potentially leading to more widespread ethical issues related to role clarity and accountability.
The final thought for you is one surrounding clarity: try to clarify expectations every step of the way. Clearly communicate expectations for juniors regarding their tasks, deadlines, quality standards, the definition of done. Ensure that they understand what is expected of them and the impact of their work on the project and on each other.
Sources:
- https://selleo.com/blog/what-makes-a-software-developer
- https://www.freevision.co/blog/what-is-the-difference-between-junior-and-senior-developer
- https://zaidesanton.substack.com/p/hiring-only-seniors-is-worst-policy
- https://www.wearedevelopers.com/magazine/difference-between-a-junior-mid-and-senior-developer
