What Is a Senior Developer and How Can I Become One?

Becoming a Senior Developer is something many of us strive for as we continue our code journey and build our career. But what does it actually mean to be a “Senior” Developer?

What being a Senior Developer is not

Before we start, let’s get this out of the way. Contradictory to what you’ll see on 95%+ of the job postings online, a Senior Developer is not strictly correlated to only the number of years on your resume.

It’s true, more often than not, that many years on the job typically bring with them a lot of experience. And with some companies you can get by with just that. But it’s not the only quality that rightfully proves that someone is at a Senior level.

This is a common problem in the software world and can lead to high expectations with low delivery. It can also lead to conflict within the team when your new 15 year 10x Senior Developer refuses to work with others.

So what can we do to prepare ourselves for that role?

What makes a Senior Developer?

Looking back through my career at the developers on my team that I’ve admired and respected the most, it’s really come down to four qualities:

  • Experience
  • Leadership
  • Mentorship
  • Technical Ability

It’s not good enough to look at any one of these as the sole representation of how someone will perform on a team. Each developer is unique and may be stronger with one quality than another. But it’s important to see how those qualities come together to determine how someone will help your team grow.

Let’s break these each down a little bit.


Experience is typically thought of as years on the job, and while it’s not completely inaccurate, it doesn’t tell the whole story.

Just as every developer is unique, so is their experience. While one developer might have spent five years in an intensive position where they worked to solve hard technical challenges every day. And another might have been kicking their feet up at a local shop where their only responsibility was to update the website every week.

And that’s not necessarily a bad thing! We each have our own journey and need to balance our lives to fit it. But it’s not realistic to say those 5 years were the same.

Then what does experience really mean?

Recognizing patterns from previous work

Every developer has a story (whether they remember it or not) of a random error they stumbled into through their development experience. This could be something dealing with Javascript, webpack, or even your operating system, and it just doesn’t make any sense!

But whether through a peer or by searching on Google, you figure it out. And three months later when you’re working on another project and run into the same thing, you don’t even have to Google it, or you already know what to Google. You already know what the issue is and can get past it quickly and move on.

This is the kind of experience that makes a difference. Being able to recognize patterns whether because of an error or because it was super successful is what helps each of us grow. These are the experiences that help a team grow when others are stuck and you can get them out of a bind.

Recognizing what you don’t know

It’s also important to understand what you don’t know. I think part of what contributes to my own personal struggle with imposter syndrome is that the more I learn the more I realize I don’t know.

But this shouldn’t be looked upon as a bad or scary thing. This should be inspirational. That means that your craft that you’ve been working on has that much more cool stuff to explore!

It’s important to realize how this impacts your work and the rest of the team. For example, it doesn’t help anybody if you act like you know everything and commit to huge amounts of work. When you commit to that work and actually don’t understand it, it could knock your sprint off track which can frustrate the entire team (and the client).

Whether it’s when you’re planning or during development, don’t be afraid to ask for help. Come up for air and throw your hands up! Just because you’re the only Senior Developer, doesn’t mean you can’t learn something from a Junior team member.

Try to take a good look at where you’ve been, what you understand, and where you could benefit to dig in more.


As a senior member of a team, I would expect a developer to have a natural tendency to lead. While this doesn’t mean you have to be an actual Tech Lead on a project or make any of the final decisions, this does mean that you should have a basic level of being able to help push the project forward

Understanding the bigger picture

If you’ve worked on projects with team members, you should know that each project or feature typically comes with a bunch of stories to work through to get it done. Each story should be a focused piece that helps accomplish a larger goal.

Where this becomes challenging is if no one on the team understands how each of these stories help to accomplish that bigger goal. As a Senior Developer, you should be able to see how each piece fits into the puzzle and why the story is written with the specific acceptance criteria. And if you don’t know, you’ll know how to get the answers and make sure it’s communicated to the team.

If you’re unsure of the direction, try to take a step back. Try to see where it fits in. Help to lead the project team to that ultimate goal.

Helping direct less experienced team members

This comes naturally in the ability to help guide those on our team who are more junior or less experienced. It’s common for developers to lose focus on the big picture. But as we just discussed, a Senior Developer should be able to continuously have a good idea of the overall project and where the different stories fit into the bigger epic.

Help guide others on your team to get them on the right path. While it would be beneficial for everyone to understand how everything fits in to the bigger picture, sometimes it makes more sense to help an individual focus on how their specific task fits in.

Try to recognize this struggle when working with others whether by encouraging them to ask more questions or helping to guide them if they’re not quite on the right path as you’re reviewing their code.


It’s often more convenient to be heads down on your work and not have to worry about what anybody else is doing, but is that really benefiting anyone?

Helping to build up other team members

You might be the so-called 10x developer, but doing everything yourself and not helping others can only slow down the overall team. Often you’ll be stuck picking up the pieces that you could have easily caught if you spent an extra second pairing up with someone else on your team.

It’s also bad for morale. No one wants to feel alone on a project and even more so as a junior. Software is a big scary world, a little guidance can go a long way to helping others to become more productive and subsequently encouraging a happier, less stressful environment.

It’s easy to forget that we were all a junior team member at one time. While you might take things for granted, the concepts might be really challenging for others to grasp.

Keep in mind that we’re all in this together. Celebrate the wins whether big or small. If somebody’s struggling, reach out to help.

Knowledge sharing

Sharing knowledge is something many teams struggle with. While we’re all usually hopeful that there’s a way to accomplish it, most of the time it just goes unsolved. So what can we do?

Take it upon yourself to share what you know. Did you just rework the core business logic? Offer 30 minutes to walk everyone through the code. Pair up and screen share with your code reviewer if they’re having a hard time understanding it.

This is something we can encourage everyone to do. You’ll naturally learn more by presenting your work by reinforcing what you just worked on. This is helpful whether you’re a Senior or it’s your first time opening up a code editor.

Technical Ability

I intentionally wanted to leave this until the end. This is because, while it’s important, there are more aspects to your journey to becoming a Senior Developer than just being really, really good at something.

Ability to get moving quickly

As a Senior Developer, I would expect another Senior Developer to become productive in something quicker than a Junior Developer. If they’re an expert with Javascript, I would expect them to understand the core principles and patterns of the language.

But back to the idea of recognizing what you don’t know, it’s not reasonable to expect all Senior Developers to know everything. I wouldn’t consider an expert in Ruby any less of a Senior Developer because they don’t know Javascript, but I would expect them to understand how to apply what they know when building in and learning another language.

Promoting software patterns

More often than not, the code pattern you just came up with isn’t new. And that’s okay! The goal of building great software isn’t necessarily to be unique with every solution.

And because of that, we can learn from past work by seeing what’s succeeded and what’s maybe not gone over so well to find patterns that work for you and your team.

Patterns like MVC (Model View Controller) didn’t become popular without reason. Developers learned from the past and have learned from their peers who have solved big software challenges. With that knowledge, they can apply the solutions to their own work. It’s not about reinventing the wheel, it’s about solving challenges and making a good product.

We all have our own unique journeys ahead

No matter what anyone tells you, we all have our own unique code journeys. This is meant to encourage you and inspire you to become a better overall developer and understand how your work impacts the rest of the team.

While you certainly might succeed without taking these things into consideration, you could be missing out on core traits that could make people not want to work with you from a human being perspective.

Whatever your journey, keep these things in mind as you grow into becoming a better developer!

What do you think makes a good Senior Developer?

Source link