There is always a need for skilled senior developers in the hiring market, contributing to their high salaries. Many people want to get into software development and reach the senior level one day. We’ve prepared a detailed roadmap on how to get there faster and without wasting time learning things you probably won’t need.
The path to becoming a senior developer is indeed long and challenging. For most people, it takes approximately five years. Of course, some exceptional hard-working geniuses get there much faster, and those who prefer staying inside their comfort zone remain on lower levels for multiple years. But don’t get discouraged! Becoming a great software developer doesn’t take much talent, some unique brain structure, or other voodoo magic. It’s just long years of practice combined with continuous learning.
You can’t become a senior developer in an instant. A typical engineer will start as a junior developer, advance to mid-level, and only after that reach senior level. Of course, there are forks in a career path, often to more managerial positions, but that’s a topic for another article.
Feel free to navigate the sections that describe your current level and next promotion. For junior developers, trainees, and people just starting, we suggest reading the whole article to get a clear picture of what’s ahead.
Choosing Your Direction
If you’re entirely new to software engineering, you are probably thinking of what language you should learn first. Learning a programming language is the first step to becoming a software developer. However, the choice depends on what pieces of software you want to build over the next couple of years.
First, you should choose whether you want to learn to develop only the client-facing application that users see on their phones and browsers, the invisible back-end APIs, or both.
The front end is usually considered the easy part of every project. You’ll be dealing with HTML/CSS, some UI components library, UI framework, and pretty repetitive and straightforward business logic most of the time. Sometimes, however, the tasks would be highly complex and involve doing something that has yet to be done. That might include developing new user interactions, components, or fancy graphics. Those tasks are usually for skilled mid-level or senior engineers, though.
Unlike front-end development, where junior engineers might get away with only learning the language, framework, and best practices, the back-end requires more theoretical knowledge from the very beginning. Yes, you probably write simple CRUD APIs most of the time, but quite often, you’ll be designing systems that require complex data structures, algorithms, and more profound database knowledge. Security, scalability, code design, and software architecture are also more critical on the back-end.
Full-Stack development is not recommended starting direction for beginners. Essentially, it’s both front-end and back-end combined. After you’ve mastered either of them and want to build the whole project from scratch, you start learning full-stack development. Often it starts from a pet project you develop in your free time. Sometimes, another team on a daily job gets overloaded by tasks, and you help them.
Inexperienced full-stack developers are often jacks of all trades and masters of none. To become a full-stack expert, one must gain tremendous software development experience with different technologies. Starting with just one direction at first is more accessible.
Junior developers can complete basic tasks without supervision and intermediate ones with some guidance. They aren’t the first people starting new projects and are not very involved in architecture design, but they write a substantial portion of the actual code on both simple and large projects.
An essential trait of a junior developer is autonomy. Valuable junior developers achieve good results with as little supervision as possible. Besides the programming language knowledge, they also need a minimum skillset for good code design and development:
- Debugging, testing, and monitoring the code.
- Working with code repositories, like git.
- Know a few data structures and algorithms and where to use them.
- Understand basic design patterns.
- Have basic knowledge of IT and how web applications work.
- Know OOP, and have a general understanding of procedural and functional programming.
Front-end developers also need to know their framework of choice and its best practices together with HTML/CSS and some UI component library or CSS framework. Back-end developers must know NodeJS, a few databases, and a little about deployment. Full-stack junior developers are rare as they need to understand a bit of everything.
Feel free to see the required and recommended skills list on our competency matrix under the “Junior” section. We’re aware that most junior developers only know some of it. Still, knowing it all would almost certainly secure your first software development job.
Middle developers own substantial portions of the project and can handle smaller projects independently. They choose the optimal code design for every task and can accurately estimate small and mid-sized projects.
Of course, they have to know everything a junior knows, but a bit deeper. Besides that, as they often manage small junior teams, they must cover refactoring, code design, and basic DevOps for the whole team. Management, understanding software development lifecycles, good communication, and soft skills in general also play a role.
Middle back-end developers need a bit of architectural knowledge to fit their pieces of code and modules into more extensive projects. Cloud, message brokers, back-end design, and architecture knowledge is necessary.
To become middle, you need more than just grinding on your junior developer daily job. You would also need to make conscious learning steps in that direction and take more ownership and responsibility for your work.
Our competency matrix’s “Middle” section might help with the learning part.
Advancing to a Senior Level
There’s one thing that distinguishes middle developers from seniors: experience. Yes, there are no shortcuts. Even more - experience with only a straightforward project or one technology doesn’t count. Senior developers need a lot of knowledge backed by practice to find reasonable solutions to the most complex problems.
They often own mid-sized projects and manage small teams when needed, at least from a technical perspective. They have to be experts in every technology a middle developer knows. On top of it, they should be able to set up all kinds of projects from scratch and provide technical guidance for others. Tech leads do this in larger teams, but even those teams are composed of smaller ones where senior developers are usually in charge.
Sometimes, in small teams, senior developers also do DevOps in production and design the architecture of the whole system or significant parts of it.
Feel free to check our recommendations for senior developers here.
Leveraging LeanyLabs Competency Matrix for Learning
Ideally, to speed up the process of becoming a senior engineer, you need a mentor to help you create a personal development plan (PDP) and guide you along the way. We provide that kind of mentorship to every developer at LeanyLabs. However, developing PDPs from scratch and finding all the necessary learning materials takes an enormous amount of time, so we decided to organize everything into an easy-to-use and easy-to-maintain structure.
Although one of the primary reasons for creating our competency matrix was to help with PDP, it became much more. The matrix also provides a list of ideas for tech talks and sets up the company’s definition for levels for our coworkers and clients. Every engineer can suggest changes and improvements, contributing to the company’s engineering culture. It also provides a simple-to-use guide for self-development. Unlike some companies, we do not enforce the matrix in any way, so it doesn’t contribute to bureaucracy or provide reasons for not promoting people. Yes, that also means we don’t have fixed and non-negotiable definitions of levels, and some people might need to learn more from the matrix on their level. We don’t enforce unnecessary knowledge on developers, and as long as they’re doing their job well on their current projects and don’t want to rotate to other projects, we’re ok with that.
The matrix covers three levels: junior, middle, and senior, across three competencies: front-end, back-end, and full-stack. Inside every position is a list of must-know and recommended skills. We consider a must-know skill frequently used or very important for a specific developer position. For example, junior front-end developers work daily with git, React, and state management. It’s also essential for them to be able to debug and troubleshoot their code both locally and in production. Every position also includes skills from the previous level.
Each skill has an associated skill level that’s either basic, intermediate, or advanced. This classification shows how hard it is to master one skill compared to the rest. It’s more of a reference and doesn’t necessarily mean that learning two different advanced skills takes approximately the same time. It points out that those skills take more time than intermediate ones and require more background knowledge or experience.
The skill has its details section that lists a set of topics that contribute to this skill. Those topics are often parts used on a daily job building real applications compared to some academic theoretical knowledge that, although essential to understand, can be quickly googled and refreshed in memory when needed.
Finally, the links provide resources to learning materials that cover most of the topics that contribute to the skill. Since it’s primarily for self-education, we preferred free tutorials and learning articles to documentation and tried to keep the list short with only the necessary information.
Start your journey by reviewing all the skills at your current level and self-identifying the gaps. Create a learning plan or PDP yourself, and start reading suggested learning material or googling the topics you might need to learn more about. Before moving to the next skill, remember to recheck the topics and ensure you understand everything from the current skill.
It’s one of the quickest ways to advance your software development career. Even if you’re lucky enough to have a mentor, feel free to go through all the skills in the matrix with them. That way, you reduce the chances of missing out on something essential and grab a list of quality learning materials for you to read.
If you have any questions or suggestions for the matrix, don’t hesitate to contact us using the form below.