How To Become A Senior Developer
28 May, 2019
A while back, I wrote about the stages of your software development career where I laid out a simple way to think about the general steps that most developers will find themselves in during their careers.
Before I started this series, I also touched on the difference between a lead and senior developer.
Now, it's time to have some more fun and take a closer look at what makes a senior developer, along with some tips for aspiring senior developers!
Who's A Senior Developer?
To recap from a past article, a senior developer is really marked as someone who:
- Is competent in the core technologies used in his/her company
- Usually has some specialization
- Has a handle on high-level architectural concerns and design
- Should have a number of years of experience (something you just need to gain through the school of hard-knocks)
- Experienced building "full" real-world solutions
- Actively mentoring and coaching other developers on their team
The last point, I would say, is the best indicator that someone is a senior developer.
If you've proven yourself trustworthy by:
- Showing you can solve tough technical problems
- Demonstrated yourself as a good communicator
- Having real-world experience that frames many of your decisions
Then, your co-workers will look to you as a leader and coach.
Becoming An Adult?
My article about becoming an intermediate developer compares the intermediate developer to someone who's entering into puberty - but for their career.
The senior developer is like someone who's grown up, become an adult, and can take care of themselves. Their life is not as erratic, spontaneous and experimental.
That's because, in many cases, they've already "been there and done that."
They've learned from their mistakes. They've had many experiments and have formed a solid foundation for their lives, as it were.
Life is not as fantastical when you become an adult. But you do understand the world much better, and you understand that there is a huge world beyond your own perspective.
Just lay that analogy on top of the software developer, and you get a sense of what a senior developer is like 😋.
Senior developers are more cautious, thoughtful, pragmatic, practical and simple in their approaches to solving problems.
They've learned what works, what doesn't, what might be too abstract, not practical enough, useful, effective, etc.
Seniors are confident in what they know due to their experiences. But they also have a grasp on the fact that there's so much they don't know about.
Breadth And Depth
You might have heard about the idea that a senior developer's skills ought to be "T" shaped.
This means that they have a fundamental understanding of many topics (the top horizontal part of the "T"). But there are one or more areas where they have a very in-depth knowledge and skill set.
Senior developers have wide-reaching knowledge about what tools and techniques solve specific problems.
For example, I've never had to build a production-ready distributed microservice system. But I'm aware of what problems this architectural approach solves and I know about different ways to begin thinking about how to structure them.
I've never had to use event sourcing in a production-ready application. But I know what kinds of problems it solves.
Just a few weeks ago, I recommended to my dev team the options of using some graph database tables to solve certain performance issues. I've never built a full system with node/edge tables, but I know what problems they solve!
Again, this is a key trait of a senior developer:
Senior developers know what solutions are available to common/re-occurring programming problems.
On the vertical part of the "T", there should be some specific areas where a senior developer is very skilled and knowledgable. Many times, this expertise is directly related to a specific role they have.
There should be some specific areas where a senior developer is very skilled and knowledgable.
Either way, a senior developer is an expert in something, and continues to grow in other areas too!
This might be specific areas like system architecture, a particular programming language, a programming paradigm (OOP, functional, etc.), a certain set of technologies, security, performance, or even just having extensive knowledge of a specific industry!
As a junior developer, you're still learning about how to build software. Things that come to mind are:
- What patterns are available / when and how to apply them
- How to deal with business requirements that are given to you
- How to estimate your work
- How to connect various systems together
Senior developers have gained experience building solutions, managing complexity, dealing with confusing business requirements, applying design patterns, etc. Because they've done these things so many times, over and over, they can solve many common problems "by heart."
A senior developer can look at a problem that a junior or intermediate developer is facing, see the patterns involved in that problem, and they know - based on patterns they've become accustomed to - the general way that the solution ought to be discovered or implemented.
A senior developer uses common patterns to discover the general path to a proper solution.
If you are looking to become a senior developer, this "zen" can really only come from having real-world experiences where you've learned from failures, successes, mentors, etc.
You just need lots of practice and need to do these things so many times that they become imprinted into your brain!
And of course, how long that takes depends on the intensity, variety, etc. of the work you do during your job.
As a side note: if your job is not challenging, then chances are that you will not grow very quickly.
Using my own journey as an example, my first job was being part of a team that was building a new software system which dealt with automotive manufacturer finances in a new way for that industry.
I quickly had to deal with a very large codebase, got my hands dirty in front-end, back-end, database programming and everything in between!
After growing for a couple of years, I was asked to help build a new white-label platform for insurance companies that allowed people to apply for life insurance using the web.
Being in charge of building the entire web portion of this project really caused me to grow. I learned so much! Including what not to do 😋.
This project had really complex business logic (that had already been developed and was ported to this project). It was very difficult to understand and manage. This made me seek out patterns and tools around how to manage business logic in software.
Once I started using these techniques, patterns and principles in my own code, other developers would come to me and start asking about them!
Because I took the time to invest in learning about these patterns and techniques, today I'm constantly helping my team with these kinds of architectural and code organization concerns.
What can you gain from all this? Here are some tips for becoming a senior developer that can be gathered from what we've gone over:
- Figure out what tech stack you really want to be skilled with and learn it in-depth
- Read every day! (This will help you become a better reader and just help you learn every day)
- Try to take on those really hard yet valuable projects that are offered to you
- Remember that experience comes with time - there's no other way!
- Remember the concept of the "T" shaped skills set
- Map out your skills and figure out which ones you want to really dig into and which ones you want to learn the fundamentals about
- For skills where you want to know the fundamentals, the most important thing to understand is what problem(s) does it solve?
- For skills that you want to dig into, consider mentoring or high-quality training material (think Pluralsight)
- Most fields will benefit from knowing design patterns (again, the most important thing is to know what problems each pattern solves)
- If your current job isn't challenging, consider moving on to something more challenging
You might notice a common theme among some of these: learning techniques and patterns are mostly about knowing what problems have solutions to them.
Skilled senior developers can point out specific problems, remember what techniques or patterns can solve them, and learn or re-learn how to implement those solutions on-the-fly whenever needed!
Here are some of my technical articles that could be used as starting points for digging into topics which I've found helpful in becoming a senior developer:
- 6 Ways To Implement The Strategy Pattern In C#
- Refactoring Legacy Monoliths Series: Parts 1, 2, 3, 4
- Async/Await For The Rest Of Us
- .NET Core Dependency Injection: Everything You Ought To Know
- Introducing Gate Classes
- The life-changing (and time-saving!) magic of Feature Focused code organization
- Fluent APIs Make Developers Love Using Your Libraries
- Where Do I Put My Business Rules And Validation?
Next in this series: Essential Senior Developer Skill: Solving Problems With Patterns
All of my articles are sent out via an email newsletter first.
If you want to stay updated, get new articles early and have additional career tips then sign-up!