Introduction
I have been working as a developer for about 17 years. During that time, I noticed quite a low bar for becoming a senior developer from a junior. This blog post looks at what I believe are some requirements, trends, and misconceptions for becoming a senior developer.
Some misconceptions
Let's start by clarifying some misconceptions and trends first.
The drive toward senior classification
Consultant companies want to classify a developer as senior as quickly as possible to charge a higher hourly rate to the customer, potentially at the expense of the project, customer, and developer. It is not a good feeling to be labeled a senior developer with imposter syndrome at the max level.
Timeframe to Becoming a Senior Developer
There should not be a timeframe for you to become a senior developer automatically. If you work on the same set of problems and do not push yourself to learn more in the breadth of software development, then it isn't easy to advance. As an extreme example, you create minimal .NET APIs repeatedly but never deploy them into production due to a lack of K8s knowledge. You write unit tests but never interact with the end customer to gather requirements for Behaviour-driven Development tests. Are you then progressing to seniority?
Junior Developer
A junior developer is typically someone beginning their software development career. They are usually characterized by:
- Limited professional experience (0-2 years)
- Requires guidance and mentorship from more experienced developers
- Focuses primarily on learning fundamental programming concepts and team workflows
- Works on smaller, well-defined tasks with clear requirements
- May struggle with complex technical decisions and system design
- Requires clear, already established tasks
- Focuses on a single task
In my experience, a junior developer often gets hung up on low-level details and "best practices" without looking at the context. I have, for example, heard, "If everyone programs in GO, then there would be no problems." This was said jokingly. However, it speaks to the narrow-minded focus.
I have previously written a blog post about the Dreufys model for skill acquisition. This model, which explains the various steps from junior to expert, is a helpful framework for understanding the progression of a developer's skills and responsibilities.
I remember starting in my first professional job. Everything was new. I learned the concepts, underlying structures, and how to think from university. However, there is nothing about version control, build systems, and billing, to name a few. One significant difference between school and the real world is the constructed assignments that hide much of the complexity. Meanwhile, the real world is so much messier. All of which hits you with full force.
Senior Developer
Senior developers have evolved beyond writing code to become comprehensive software professionals. They are characterized by:
- Deep technical expertise in their primary technology stack
- Ability to mentor and guide junior developers effectively
- Strong system design and architecture skills
- Can handle complex, ambiguous problems independently
- Takes ownership of entire features or projects from conception to delivery
- Understands business context and can translate requirements into technical solutions
- Proactively identifies and solves problems before they become critical
- Makes informed technical decisions considering long-term implications
- Contributes to technical strategy and architectural decisions
- Has experience with full software development lifecycle, including maintenance and operations
As a Senior developer, you don't just complete assigned tasks—you actively participate in shaping the technical direction of projects, mentor others, and take responsibility for the overall quality and success of the software you build. Your role is not just about coding but also about influencing the project's trajectory and ensuring its success. I will not go into all of the points here but instead, highlight some of what I consider the more important ones.
Takes ownership and leads from within or from the front
A senior developer tries to see the entire project, from business requirements, stakeholders, DevOps pipelines, development, tests, scaling, and team culture to the finished product running in production. Getting a better grasp of the overall context helps the senior developer balance what to spend time on. Maybe it is not a good idea to spend all the time polishing a car if it is missing a wheel.
Leading from within means that you do not necessarily need to be the appointed architect or lead developer. You could come up with ideas about improving the code structure, analyzing the requirements, setting up production, etc. I have seen developers literally sitting with their hands in their laps, complaining about not having anything to do. That is the opposite of taking ownership or leading. I will not insult the reader with a list of alternative options on courses of action.
Placing the interest of the enterprise or project ahead of our own
Multiple times, I have witnessed developers blatantly stating that they do not know certain parts of the project, which is fine, but continue to say or mean, "So, somebody else needs to do that." This shows they place their comfort zone above what is best for the project. Instead, they could have said, "I would love to learn, or at least follow this functionality into production by asking the correct people." Accountability is the keyword here.
Making others good
A senior developer should strive to make other team members as good as possible. They have moved beyond only focusing on finishing their own tasks and helping others. How would they have liked the codebase, documentation, and various project introductions to have been when they started? Based on that question, they work on improving them for new project members.
System over application
I have previously written about a Service-Oriented Framework I developed while working at a Norwegian Power Grid Company. A system can consist of multiple applications. A senior developer values the system as a whole over suboptimalisations in a single application, such as alarms, scaling, dependencies, and diagrams showing how business processes across multiple applications work.
Intuition
After multiple projects, customer interactions, and teams, a senior developer has tuned in an intuition regarding design decisions. Of course, we should follow facts and data as much as possible. However, that bad feeling you can not explain might at least be something to explore.
On one of my first projects, my team was tasked with estimating a group of issues for the upcoming sprint. I noticed that the more senior a developer was, the higher the estimate. When asked why, they could partly explain it. They used their intuition. It turned out they were right.
Solutions over "best practices"
After a while, a junior developer will identify problems and challenges. A senior developer will extend that with practical solutions that solve the problem and act as a basis for future functionality and systems. Seeing the problem is only half the way there.
Cloud Native example
Looking at an example can make the junior and senior distinction clearer. Creating a platform team that brings enterprise value requires multiple skill sets. The team often comprises junior and senior developers from different backgrounds, such as developers, on-prem infrastructure, and project managers. The senior developer will be mainly responsible for interacting with the potential end customers, often the stream-aligned teams in the organisation. They use their intuition and experience to choose between the vast number of tools and setups to serve the current customers best and set a basis for future expansions. The junior developers are often at a lower level, implementing the setup outlined by the senior engineer.
Conclusion
Becoming a senior developer is not just about years of experience or technical skills—it's about mindset, responsibility, and approach to problem-solving. A senior developer should demonstrate ownership, leadership, and a system-wide perspective while actively contributing to the team's and project's success.
The journey from junior to senior is unique for each developer and shouldn't be rushed by external pressures like consulting companies' desire for higher billing rates. True seniority comes from diverse experiences, handling complex challenges, mentoring others, and developing an intuition from facing and solving real-world problems.
Most importantly, senior developers need to look beyond their immediate tasks and comfort zones, focusing on the overall success of the enterprise while helping others grow. They understand that their role extends far beyond writing code - it's about building sustainable systems, fostering team growth, and delivering value to the business.