This article is strongly opinionated. The Senior role depends on many factors, most of which I'm pointing out in the article. In addition, the article points out the perspective of Senior Developer.

What Does It Mean to Be a Senior in Something

I've decided to write this article because many people write to me directly and ask how they can start to become a Senior developer. This is likely because they know that I work as a Senior Dev in my current company.

I prepared a snippet that I can copy and paste into every message. It's a good idea to create an article about this because the Senior role depends on many factors such as experience, technical skills, leadership skills, soft skills, management, responsibility, and curiosity. I could go on listing these factors forever.

Skills and Knowledge

It may feel like if you're good at something, after gaining some years of experience, you will probably become a Senior Developer automatically. Hmmm, it's not like that (～￣▽￣)～.

Skills and knowledge are important and that is a factor that is required to be a Senior, however it's not the only one factor. Why?

Let's consider a quick example. Imagine working with a guy who is a perfect coder. His code is always impeccable, thoroughly tested, and functions flawlessly. However, he tends to keep his knowledge to himself and doesn't share it with others. He acts as if, "I have my work to do, and I don't care" about collaborating or helping others.

If you're good at something it usually means that you're good, and that's all φ(*￣0￣).

Experience

Having skills is important, but experience gives you the ability to execute tasks more efficiently. Therefore, a Senior developer must have experience; without it, the role becomes significantly challenging. Knowledge and skills alone are not sufficient - sadly, that's the reality.

I cannot provide a specific number of years of experience or project qualifications because it largely depends on the company's needs. However, I believe a minimum of 3 years of experience is necessary.

Responsibility

This factor is really important. The Senior takes responsibility, whether it's a good or bad sprint. They acknowledge their mistakes and take action to prevent similar issues in the future.

This "learn from mistakes" attitude isn't inherent in every individual. Some people struggle to recognize their mistakes, and this can be problematic and toxic to projects. That's why companies prefer to have at least one Senior on the team, ensuring there's someone to provide guidance and accountability.

Mentoring and Knowledge Sharing

Seniors also share their knowledge, demonstrate best practices, and teach others while continuously focusing on overall team improvements. They identify gaps in the knowledge of team members, share relevant materials, and educate their colleagues.

Of course, it doesn't mean that every Senior will be the best teacher; it just means that they usually strive to enhance the skills of team members.

Authority

In projects, Seniors need to have authority. Without it, their comments on pull requests, their words, and their decisions may be ignored or challenged by project owners or technical team members.

I'm not suggesting that challenges are inherently negative. However, constantly questioning or challenging others due to a lack of trust can hinder progress and diminish the value we provide.

PoC Makers

The PoC (Proof of Concept) is a crucial step in software craftsmanship. It demonstrates whether an idea is feasible, estimates its duration and complexity, and typically highlights the risks and strengths of the concept.

This step is strategic and requires preparation by an experienced and skilled developer. If done incorrectly, it can lead to unpredictable consequences for the project in the future.

Therefore, Seniors step in and conduct PoCs for the most critical and challenging parts of a system. They make decisions that steer the project in the right direction.

Anti-Drama Protectors

We're all humans, and sometimes under high project pressure, someone may take comments in PRs personally. Seniors are adept at spotting such conflicts and strive to resolve them. As developers themselves, they understand the perspectives of other developers, as well as those of non-technical team members and the business.

The Bridge

Business requirements must be written in tickets, sometimes with a dose of technical information. Seniors excel at taking plain business needs and crafting well-refined tickets that are easy for others to understand.

Realists

If there is a problem, Seniors identify it and bring it to the team's attention. They simply describe reality, even if the truth is painful because they recognize that continuing with a flawed solution in the long term is detrimental. They strive to improve it.

Communication

A Senior should be able to quickly and clearly articulate what is most important. Strong communication skills save a lot of time for both you and those who listen, as they help minimize questions and doubts.

Decision-making

We could discuss certain topics indefinitely; it might seem like a never-ending story. However, at some point, someone needs to make a decision. What tech stack should we use? Which scope in this sprint is the most important? What needs to be prioritized and in what order?

Seniors are responsible for making such decisions and taking accountability for them.

Problem-solving

Seniors are exceptional problem solvers. They can identify hot spots, break down complex problems into smaller parts, delegate tasks to team members, coordinate necessary actions, gather missing information, and oversee the overall process.

Strategic Thinking

Focusing solely on the current state of the system is risky. Seniors have a broader perspective; they think strategically. They consider factors such as future developments, costs in terms of maintenance, hiring other developers, and more - looking ahead by a year or more.

They protect both sides - clients' money and the goal of producing well-standardized solutions.

Git Mastery

Seniors are proficient in every Git command and understand the importance of a well-documented and maintained Git history. They handle conflicts, maintain releases, create workflows, frameworks, and other crucial aspects related to source control to maximize benefits.

Collaboration

Seniors recognize the value of teamwork. They prioritize team goals over individual achievements and strive to safeguard the overall direction of the product and each sprint. They ensure that the team focuses on the most important and valuable tasks.

Good Enough

Seniors understand that a "good enough" and stable solution, thoroughly tested, is often the best choice. They prioritize business value, performance, scalability, and test coverage over specific design patterns or implementation details.

However, they don't obstruct someone's work just because they believe the codebase pattern is suboptimal. Instead, they highlight inconsistencies and provide explanations. They also acknowledge that their solution may not be perfect and that the simplest solution is often the best.

Self Improvement

Seniors acknowledge that nobody can know everything or be the best. They constantly strive to improve their skills and knowledge, making daily efforts to do so.

While I'm not suggesting this is a golden rule, in today's rapidly changing world, learning within just an 8-hour workday is nearly impossible. While there may be some exceptionally talented individuals, our field demands constant self-development. In my opinion, those who don't embrace continuous learning may never reach the level of Seniors.

Summary

This was a strongly opinionated article, but I believe some of the points I've raised probably align with your perspective as well. The Senior Developer role is built upon many factors, some of which depend on the current company's needs.

You might be considered a Senior in one company, but not in another. It's not a binary term, and it's impossible to categorize it as such.