The road you need to take to become a senior developer is huge.
It is a difference that most developers underestimate — I know I did back in my early days of writing code.
It involves mastering testing, design patterns, and clean code. But, more importantly, it means having higher standards.
It means caring about getting the code to work and keeping it working in the future. It is about the standards YOU set for yourself way beyond the quality of your code.
It means replacing copy-pasting Stackoverflow answers with understanding how it all connects. Understanding that building software is so much more than coding.
You must move away from memorizing bits and pieces, you must see the big picture.
And unless you can shift your thinking effectively, you will always be just another developer.
That is why some developers skyrocket their careers while others spend years looking at the same legacy code, stuck in the same job with no real prospects for their future.
So what can you do?
You start doing things right when no one is watching. You stop taking shortcuts and you stop copy-pasting. You widen your perspective.
To effectively become a senior developer, you must develop a higher level of self-awareness, both technical and personal.
I am lucky to live in Berlin.
Four years ago, I moved here to accelerate my software career — a digital capital where the software industry has been growing massively since 2010.
By watching the software community here, I witnessed the massive shift the software industry is going through right now. We used to talk about React; now, we talk about Web Components and Microfrontends. Now, we talk about server-side rendering, performance, and time to the first byte.
I live a few blocks away from the headquarters of the big European tech. N26, Zalando, Delivery Hero, a decade ago they were tiny startups.
Now they are public companies, employing thousands of software engineers worldwide — and they claim not even to have reached the maximum point in their growth.
With startups becoming multinational conglomerates, the software industry is growing exponentially, and so do the requirements of what it means to be a senior developer.
In software development, the game is just getting harder.
Funny enough, it wasn’t until I quit my developer job and coached 80+ developers that I became aware of these massive industry changes.
I realized the increasing complexity developers are exposed to right now — the industry is growing, and technology is becoming much more complex.
If we want to survive in this industry and have a future as programmers — we need to transcend ourselves.
Since I have done this myself, I have also helped dozens of ambitious developers develop the technical expertise, depth in thinking, and discipline it takes to get to senior level and beyond in this new environment.
Here are the fundamental lessons you need to learn and mistakes to avoid when becoming a senior developer.
Most importantly, here is how to do it in 3 simple steps.
You can’t fix a problem if you don’t know it exists.
As developers, the “community” bombards us daily with things we don’t know: new libraries, new tricks, new ways to do this, and that — thousands of blog articles, youtube videos, courses, and workshops that we should get our head around.
Suddenly, you must master design patterns, data structures, microservices architecture, web performance, algorithms, and git commands to get by.
But, let me ask you this, how many of those shiny frameworks will bring your technical skills forward?
In reality, very few.
First of all, because your time is limited, you can’t possibly learn everything out there.
Second of all, because most of them are nice to have. Will knowing 100 bash commands fundamentally change your understanding of software? Will memorizing exotic algorithms on Leetcode make you more efficient at your job?
Most likely not.
Doctors don’t prescribe you the medicine that it is trending right now; they give you the medicine you need and the one that’s proven to work.
To successfully go to senior developer, you must first understand the exact gap between where you stand right now and that “go-to” expert engineer. That part depends on the size of the companies you worked for and the codebases you have been working with in the past.
The gap in your technical skills is not something you can understand in 2 minutes and jump back to your Udemy account.
To get your technical growth unstuck, you must know what you don’t know.
You must take your time, do a bit of self-reflection and be strategic.
Look, programming is not complicated.
Even a high school student can get some lines of code to work. The hard part is getting those lines to work tomorrow as well.
To make them easy to understand, easy to maintain, and easy to extend. That is hard.
It is about making things clean and giving them structure. Juniors care about making it work today, senior developers care about how is going to work tomorrow and the day after tomorrow.
You see, we all know we should write clean code. But when the deadline is getting close, we start taking shortcuts.
We hard code things, repeating ourselves and being all over the place.
I get it; your manager only cares about the feature you deliver and you don’t want to get fired. The code doesn’t look great, but you will fix it later. For now, you just want to deliver so you copy-paste a bit and make it work.
Then another project comes up, and you forget. Life quickly gets in the way. You forget again.
One line of bad code becomes a module. A module becomes a project. Suddenly you are surrounded by this spaghetti code monster.
You lose motivation.
Sooner or later, you wake up asking yourself, “how the hell did I even end up in the middle of this mess?”.
Senior developers know their intuition is not fooling them. They know that when they take too many shortcuts, they are creating technical debt. A debt they will have to deal with through late evenings and extra weekends.
Even when the pressure is high, senior developers don’t give in. They stick to their guns; they stick to their standards.
They know Clean Code is more than a book, more than a mantra. It is a philosophy of irrefutable standards.
You can’t memorize your way into software development.
If you want to one day architect applications, not just work on some code that was already there, you must understand the principles behind what you do.
Senior developers know the “whys” behind the code you write.
That is one of the main reasons why some developers stagnate while others grow. They get stuck in the copy-paste mania.
I know many developer jobs don’t require you to think that much(in that case, you should consider jumping ship). A lot of the work is repetitive, like building some components or some APIs endpoints.
So how can you move away from memorization?
How can you learn the “why” behind things? The most efficient way we found is to pick those same things you use daily and look at them with a different eye.
Does it sound too abstract?
Here is a quick example. When people say Redux, engineers think of a state machine. When people say hooks, engineers think of separation of concerns. When people say components, engineers think of encapsulation.
In the end, the code you will deliver is the same. But your understanding of it is not.
And guess what, once you do that. Once you understand those whys, you will be able to use that knowledge in entirely different areas of software development.
So you won’t be tied to the backend or the frontend. You won’t be just another framework developer or Stackoverflow robot.
Keep doing this consistently over a long enough time frame, and while other developers will be guessing and hoping, you will get to senior level and beyond, predictably.
To successfully transition to senior developer, you first need to know what you don’t know to excel at software development.
Then, you must have the discipline to act on those gaps by focusing on patterns and things that don’t change.
You need to be comfortable with the big picture and stop relying on memorization. And you need to understand that making it work is not enough.
This is the ultimate transformation that allows some developers to make it to senior and architect positions while others jump from job to job stuck in crappy software jobs.
Do you want me to help you in your journey to mastery as a developer?
If you are interested in mastering your craft as a developer, click here and jump on a 45 minutes call with me. We will understand your goals and build a step-by-step action-oriented plan for you to excel technically as a programmer.
It will probably be the most valuable 45 minutes you invested in yourself this year as a developer.
I look forward to chatting with you soon.
P.S. A lot has been going on these weeks. We are shipping the 3rd version of our Software Mastery program. Within all this mess I can barely find time to write. But, I am getting back to it. All I ask is a bit of patience. In the meantime, if you want to join the group of developers who know they are smart and they can be even smarter, hit me up, and let’s have a chat :)