Today I'm sharing a conversation I had with Ben Ilegbodu.
For those who don't know Ben: He is a Principal Frontend Engineer at Eventbrite and a member of the React and TypeScript communities. Ben's a Microsoft MVP and holds an MS in Computer Science from Standford.
Ben shared a huge amount of wisdom and expertise concerning the process of becoming a senior engineer, but one bit really jumped out at me. Ben said, "There are a number of different qualities that I feel like compose seniority," then went on to share three key characteristics that he felt made one "senior."
The ability to develop quickly
This characteristic feels obvious to me, but there is more to it than just shipping a ton of code in a short period.
This also contains the more nuanced skill of writing the correct code early. Being a senior means, you should spend less time chasing incorrect solutions.
The ability to teach others and help others grow
Ben referred to this as leadership.
Teaching others is a significant part of being a senior engineer.
Unlike the first and second characteristic, this trait doesn't always get developed by writing a ton of code. Learning to articulate your thoughts and cultivate others is a skill that can be learned outside of the technical world.
The ability to find the ideal solution
This trait is the most difficult to quantify.
I felt like it could be labeled as the "artistry" part of what software engineers do, the sixth sense that develops with experience.
Ben referred to this as being able to find the most elegant or scalable solution depending on what the situation required.
After having spoken with Ben, I feel like I've got a much clearer idea of what it means to be a senior engineer. Going forward, I'll be searching for opportunities to exhibit these traits in my career.
What kind of traits make someone "senior" in your experience?
P.S. If this kind of stuff interests you, listen to a couple episodes of devpath.fm :)
Top comments (11)
In my view one of the more important traits of a senior is the ability to recognize that "ideal" or "perfect" are either myths or unnecessary and "good enough" is typically what anyone ever wants at the time.
Why waste your time looking for the perfect solution when you could already be done with the good enough one that fulfills all your actual needs? Just try to make sure you build software where decisions can be changed later.
Nice! Want to hear the episode but can't find your podcast on Overcast!
Also, the link above is broken... :(
Thanks for letting me know. Here is a link to the episode: devpath.fm/episodes/principal-fron...
I'm still waiting on the green light from Apple for iTunes, which is how Overcast picks up their shows. Hopefully, it won't be too long. You can listen to it via the web player, Spotify, or a handful of other apps like Pocket Casts.
Cool! Let us know when it is out on iTunes! (it's just that Overcast is already deep in my routine of how I listen to podcasts...)
Hey Daniel, I'm on Overcast now: overcast.fm/itunes1449224977/devpa...
Subscribed! Thanks.
A good senior, soon to be lead, needs the feeling to make compromises between the development department own needs and these from the business stakeholders.
It boils down to the "good enough" and the "ideal solution", but more often the balance tips over to either one side. This is all politics and not many developers like to be in that position.
Another capability a senior developer needs is being able to say "no" more often than "yes". And this is also something not many developers are aware of or like to develop as a trait in their career.
It's more about people skills than technical skills after all in this position.
Leadership is definitely one of the most important things in my opinion. Seniority is not just time passed or experience or being fast. Those qualities apply to a larger number of developers. It’s about a developer that can lead other developers in the right direction and help them grow.
Their ability to take a broadly scoped spec with vague constraints and then lead a few juniors to ship a maintainable and well documented feature that meets all the requirements that business couldn’t articulate. On time.
To me the main trait of a senior is the awareness that almost all code needs to be maintained and that maintenance often causes much more work than initial development. Code is not finished after it passes the tests. Others will have to read, understand and modify it.
Therefore a senior writes code not only for the machine to execute it but also for the fellow developers that will read it.
Typically, a senior is also good at understanding other people's code.
Yeah, I agree with this. I think that falls into the intangible skill that Ben talked about: the ability to build the "ideal" solution. In most cases, maintainability is more important than some factors a beginner might be prone to focus on.