How to Become a Senior Software Developer
It’s not easy to get hired as a junior developer1. Most companies would rather hire more experienced, senior developers instead. And they’re not keen to train juniors on-the-job, afraid that they’ll leave the company once they’re trained.
When you look at it from the point of view of these companies, the picture is equally bad. Companies report that it’s easier to raise capital, than it is to find developer talent2. Tech recruiters make a killing from the shortage of developers, and companies are paying a premium for quality hires3.
This is an opportunity for the developer who knows how to do her work well. The elusive senior developer, with “10+ years of experience.” The problem is that you, and the market, don’t have time to get 10 years worth of software development experience.
What we’re going to discuss in this tutorial, is how you can grow to a more senior level in a shorter amount of time. How do you become a senior software developer without those “10+ years of experience”? Where can you start right now?
Let’s get started.
- The Gap Between Junior and Senior Devs
- Characteristics of Senior Software Developers
- Soft Skills: Senior Developers in Teams
- On Making Mistakes, Curiosity and Innovation
- Further Reading
The Gap Between Junior and Senior Devs
Here’s a shorthand for the level of experience of a software developer:
- Junior: 2-3 years of experience
- Senior: 10+ years of experience
- Medior or “mid-level”: in between junior and senior
This years-of-experience shorthand has a problem. It doesn’t say anything about the quality of software development. How much experience and skill did you attain in those years?
This is why job interviews for developers are so complicated. It’s hard to measure skill, so we’re giving developers tests. These tests rarely represent the work you’ll do at your job, but it’s the best approximation we have.
To save time, these tests filter out the segment that probably won’t make it anyway: the juniors. As a result, it’s tough for junior software developers to get hired. Even though companies actually want and need developers!
I think it’s a company’s responsibility to hire both juniors and seniors, so the level of software development raises for all of us. Invest profits into skillful programmers, as opposed to dividends. Great coders will move on either way – whether you helped them move up or not.
These are all symptoms of a much bigger problem: there’s no clear path through the “dead zone” between junior and senior. Once you’re not a junior any more, when do you become a senior?
According to Stack Overflow’s 2020 Developer Survey4, 39.7% of professional developers have 9 years of coding experience or less. Of all respondents, 47% has 9 years of experience or less. A sizable chunk, 17%, has learned to code less than 5 years ago. This is a huge group with a ton of potential, caught – or stuck – between junior and senior levels.
I suspect that many of the in-between developers are actually working on a level that’s on par with senior developers, or almost equal. Junior and mid-level developers can be trained and mentored to get through the junior-senior divide quicker. As a result, the years a developer needs to become a senior drops on average – so we’ll have more senior developers.
At this point I could say that more senior developers are good for the companies that want to hire them, and good for the marketplace. But to be honest, I don’t care much for these companies.
What I do care about is helping developers do their best work. That includes learning more, gaining skills and experience, and getting better opportunities. So, that’s what we’re going to discuss next.
Some companies also call their senior developers lead developers or team leads, which suggest they’re taking a leadership or management role within the development team. In this tutorial, we’ll consider leadership a competency of a senior developer.
Characteristics of Senior Software Developers
What a senior developer exactly is, is a widely discussed topic5, 6. Some articles give excellent insights into the characteristics of senior developers, whereas others overly generalize and try to put developers on a scale of “good, better, best.”
Software development is creative work. Some consider it an art like poetry or prose, even. You can’t evaluate creative work on a linear scale. What worked best in scenario A, might not work as well in scenario B. This is why the good-better-best designation of junior-medior-senior is beyond useless.
An extensive, broad skillset is a recurring theme for great developers. It’s recommended that developers gain experience in skills related to software development, like leadership, communication, product management, and understanding sales, marketing and design.
It’s hard to create a prototypical model of the senior developer. They simply come in all shapes and sizes. But that doesn’t mean you don’t recognize a senior developer when you see one. Based on that, we can establish an idea about what a senior developer is.
A senior developer…
- … has one or more concrete software development skills she specializes in
- … understands that what works in scenario A, might not work in scenario B
- … has an extensive, broad skillset related to software development
No. 2 stands out for me personally: a junior developer typically knows one approach to a problem, and always applies that same approach. A senior developer knows many techniques to solve a problem. They can decide which one to take, and transparently communicate that to the people involved in the project.
A few other traits also come up:
- Leadership: Senior developers are often asked to take up a leadership role, either directly in managing a team or as a “beacon” for product design and management. As a lead, they don’t directly manage developers, but they do have a say in product development, and help their peers along. A lead developer is someone who says: this is where we’re going; I’ll go first.
- Personal Leadership and Productivity: Senior developers aren’t more productive than junior developers, but they’re often more skilled in prioritizing work. They are communicative, and conduct themselves in such a way that the right information gets to the right person at the right time.
- Making Mistakes: Perhaps that’s the biggest mistake of a junior developer: trying to avoid making mistakes. Many real mistakes were made doing that, so the senior developer has learned to make mistakes, adjust course, and continue onwards.
- Not Dealing In Absolutes: Senior developers don’t throw Model-View-Controller overboard for being sluggish, and they don’t complain that “OOP is not functional enough.” Instead, they adapt tools to their needs, and clearly see their advantages and drawbacks. (The hypocrisy does not escape me. Some senior developers need to loosen up and innovate.)
- Always Be Testing: A senior developer does not have a fixed mindset. Instead, she’s always testing assumptions and beliefs. The plans she has might not work, and she’s the first to admit that. She’ll try anyway, testing what works, and discarding what doesn’t. This ABT approach leads to insight and progress.
- Learning And Education: When you don’t learn, you stagnate. Senior developers are always learning, trying to find new ways to apply what they know to new situations. Junior developers are often big learners too, but the difference is that a senior developer doesn’t stop once they’ve mastered something. Most senior developers know more than one programming language well.
- Must-Haves: You just can’t get around them. App architecture, Git, unit testing, code review, agile, documentation, mentoring, side projects, community contributions, emotional maturity, professionalism. They don’t make a senior developer, but they’re often expected skills. It’s OK to strike a good balance here.
You can use these ideas to find out how you want to grow as an aspiring senior developer. Let’s highlight some of them, to shape a path forward.
On software engineering: Software development vs. software engineering is a bit of a controversy. My idea about it is simple: we’re calling it software development, but we’re using engineering practices to do the work. I don’t buy into the idea that engineering has a higher status than development, simply because the engineers said so.
Soft Skills: Senior Developers in Teams
Code review and mentoring come up often when discussing the skills of a senior software developer. It appears that a senior developer has a distinct, clear role within a software development team.
Software development is an odd skill in this regard. Writing code is almost always done in solitude, but building software is most often done in a team. How does a senior software developer fit in that picture?
A particular idea about junior developers comes up: “Junior developers need constant oversight.” I disagree with that. A junior developer might need more help than a senior, but every developer needs to check their work with peers to see if it’s OK. If anything, a senior developer touches base more often.
I once joined a project where many people were developing an e-learning app together. We had a UI/UX designer, a graphic designer, people with subject-matter expertise who developed content, a project manager, an operations manager, and a few others. The development team consisted of a front-end developer, a back-end developer, and me.
What made us successful wasn’t excellent code, but excellent communication. The app worked OK, was extensible, and code was tracked, reviewed and refactored. Architecture was discussed, and needs and requirements were mapped and designed. We missed a deadline, but managed to get back on track. This was made possible, in part, because I kept the people involved up-to-date with concise, relevant and timely information.
Something similar happened when I developed a prototype app on my own, for a single client. No one other than us two were involved in the project, except for live testing after the protoype was done. Again, communication was crucial for the success of the project. The client didn’t have the funds to build an extensive app, so we had to make sure that the app was minimal and viable.
Did code quality and technical design not matter? Of course they did! The big difference between junior and senior developer, in these scenarios, was the role of communication. A junior software developer can write excellent code, but still needs to learn to communicate effectively. A senior developer excels at coding and effective communication.
And there’s more:
- Code review, and discussing how to architect a software development project, is a task often given to the (most) senior developer on a team. When there’s no dedicated project manager involved, this senior developer is often the so-called team lead.
- Senior developers are often asked to mentor juniors. This implies a status role, in which the senior teaches a junior. From what I’ve seen, it’s more effective when the junior and senior developers teach each other. You can achieve more in a weekly 2-hour workshop than in countless informal 1-on-1’s.
- Some topics are often skipped by juniors, and inherently attributed to senior developers. Architecture, Git, unit testing, TDD, and tooling. These topics and skills are so rich, because they touch on many deeper principles that are worth learning. Unfortunately, they’re skipped because they’re difficult to master.
A surprisingly quick approach to learn these things as a junior developer is to contribute to open source software. You can learn a lot about the inner workings of a project by contributing a Pull Request on GitHub. You’ll also need to communicate with other stakeholders, and adjust your work accordingly. It’s simpler to learn to deal with criticism when you publish your work out in the open.
Another approach is to simply write as you’re learning. Plenty of software developers do this, and they learn a lot by teaching others. You don’t even have to publish anything, but it helps. The same goes for helping out with Q&A on Quora, Reddit and other welcoming communities.
The bare minimum is reading open source code, and immersing yourself in your favorite GitHub repository. Perhaps you don’t feel ready to contribute code, but that doesn’t mean you should sideline yourself as a mere code consumer. You can get yourself up to speed with the codebase and help out with questions from other developers.
Let’s move on.
On Making Mistakes, Curiosity and Innovation
To me, software development is innovation. As developers we’re constantly coming up with new solutions to problems. Sometimes, that means choosing the right database platform to do data entry and automation better. At other times, it means finding and building a new implementation of some new technology like AI. At best, your code brings people closer together.
Ever wondered what the word “app” means? Most of us know it’s short for “application”. Why do we call those little square icons on our smartphones applications? It’s because they apply a given workflow or algorithm to a problem we have, and give us access and control with a user interface. Magical, isn’t it?
Building something new means you’re going to make mistakes. It’s simply never been done before, so you don’t know everything beforehand. If it had been done before, it wouldn’t be new. Reflecting on your work and improving your ideas leads to innovation. Here’s one way to look at it:
At the root of innovation lies the curiosity to find out how things work, without expectation or judgement. Innovation leads to mistakes, mistakes provide insight, and these insights fuel your curiosity once again.
The hallmark of a senior software developer is curiosity. Curiosity is a tool that gets better the more you use it, and that’s exactly what we’re looking for in an excellent software developer. A creator who doesn’t merely provide what we already have, but who can lead us to where we always wanted to go.
I know that these big words are a bit cryptic, and that’s intentional. It’s up to you to shape what you look like as a senior software developer. I can’t tell you how to be excellent, but I can give you a compass and a true North.
Here’s some ideas that can help you along the way:
- Never stop learning. Pick up a course, a book, an online degree, and use it to enrich the ideas you already have, and to get new ideas.
- Enroll other people in what you do. No one is an island, and ideas can’t form in a vacuum. Show us what you’re working on.
- Focus on the fundamentals. Make sure you understand how they work, so you can use them confidently as the basis for your work.
- Don’t tell us your ideas, show us your projects. Ideas are overrated anyway. When your ideas are put to use and spread, we can see how they work.
- Strike a balance between new and established ideas. Don’t stay a beginner forever, but don’t blindly accept ideas about what you “should” know.
- Show up. We desperately need you to lead us. Teams are lost without your ideas on how to move forward.
- Don’t just make it work. Make it extensible! Never blindly copy-and-paste solutions, and code in such a way that your future self thanks you for it.
Everything starts with curiosity. If you’re not curious, you might as well quit.
I have to admit, I don’t always take my own advice. Some of my code can’t be unit tested. Other code is so inelegant, verbose or rotten that it’ll make your skin crawl. Plenty of code clearly violates some architectural rule or design pattern. It’s definitely more than I’d like to admit!
At least I know. It’s an opportunity to do better, and I’ve learned to recognize them. Being a senior developer isn’t something you are, it’s something you get a chance to be again and again and again.
Thank you for reading this far! I’d love to hear your thoughts. Feel free to get in touch.
Code Swift right in your browser!
Go to the Swift Sandbox