The fastest way to get to the top in any field, whether it is arts, sports or software development is to study the people that are already at the top… And do what they are doing that you are not.
If you write code for a living, this means taking a look at Senior Developers. It means identifying what skills, habits, and traits they possess that you don’t.
After spending thousands of hours in the last 3 years working with top-notch Software Engineers worldwide, I found out that there are 12 Senior Developer traits that you can put in place right now to fast-track your growth to the next level.
Let’s start with number one…
1. Focus
Focus means saying no to some things, so we can do others.
Ideally, saying no to the things that don’t matter. And saying yes to the stuff that makes a difference. The stuff that moves the boat faster.
This is really hard for many developers because it goes against our natural instinct. It means accepting that you can’t do everything. And that not every opportunity is created equal.
You can’t learn every new framework out there. You can’t read every newsletter. You can’t attend every conference. And you don’t have to.
Your time is limited. So is your energy.
Being a Senior Developer means picking your battles.
“People think focus means saying yes to the thing you've got to focus on. But that's not what it means at all. It means saying no to the hundred other good ideas that there are.” - Steve Jobs
Funny enough, the better you can pick, the faster you will progress. Senior Developers have the same 24 hours in the day that you have. But they get more done.
How?
By doing less.
When a new thing comes your way, ask yourself "Does this really matter?" Or is it just another trend? Chances are it is just another distraction disguised as an opportunity.
Senior Developers say more no’s than yeses. They finish more projects than they start. And they master the framework they already work with, before learning a new one. If you want to get to Senior faster, the first trait you need to develop is focus.
2. Second Order Thinking
One thing that screams "Junior dev" is the attitude of "let’s build it and we will find out". Juniors have a bias for coding first and thinking second.
That can be a good attitude if you are just starting out, but when you are working on production-ready software, some technical decisions you won’t be able to change. Or change easily.
For example, you choose Vue as a front-end framework.
Then, requirements change. You start thinking React would be a better option. Sure, you can switch to React. But it will be neither easy nor cheap.
Senior Developers know it is easy to get high on your own supply. But if you fall in love with the frameworks and libraries you know best, you will start making poor technical decisions.
They think twice about the consequences of their choices. This can mean asking the “five whys” when trying to understand a problem.
Or thinking about the possible drawbacks their solution could have.
For example, now that we have added Redux, global state might be a bit easier to manage. But we will have to onboard new developers on Redux. The learning curve is high.
And, guess what, our JavaScript bundle will get bigger which is not good for performance.
Considering second-order circumstances will make you a much better developer. It will also help you during technical interviews.
🚨 P.S. Are you looking to fast-track to Senior Developer with quality resources, feedback, and accountability? Click here to join our Free Community - The Senior Dev Academy. 🚨
3. Pragmatism
When Junior Developers read a book on best practices, they jump and try to apply them to every line of code in any release. They follow them religiously.
If you can't make technical decisions by yourself, it is much easier to stick to predefined rules. But software development is not a religion.
A good example is Testing.
When a Junior dev reads about TDD (Test Driven Development), they will start trying to test everything. Aiming for full code coverage. When in fact, complete code coverage gives diminishing results and will turn out to be a waste of time.
Senior Devs know how to balance best practices and time to market. When to take shortcuts and when not to.
Hacking things quickly will generate bugs and technical debt. Always sticking by the rules when the context of your code changes will result in bad decisions.
You need a balance.
Be open to reconsidering your technical choices based on circumstances.
4. Nothing To Prove
Because of lack of confidence, Junior devs find themselves constantly trying to prove themselves to others. Same with Senior developers who are insecure about their value and skills.
They base their confidence on the validation they receive from others.
This is a losing game.
They will try to show how much they know in a certain technical discussion, talking over others, or pushing code late at night or over the weekend.
In reality, all these behaviors create a toxic team environment and backfire. In the best case, they will make you look less Senior than you actually are.
The Cheetah doesn’t have to prove itself in the race, it only runs to hunt.
There are two ways to deal with this.
The first one is to stop spending so much on external validation. Because the truth is you don’t need to prove yourself to anyone. Only to yourself.
The second is making peace with the negative voices in your head.
You can be your worst critic. Perfectionism, fear of failure, and a mistaken idea of what a "real" developer is are destroying your self-esteem. That’s why no matter how hard you work you always feel like falling short.
It’s time to get out of your head.
Focus on mastering your craft and the rest will follow. You will instantly become more confident in yourself and your skills. And you will stop trying to prove yourself to strangers.
5. Master The Fundamentals
Whenever I bump into a LinkedIn profile of a developer and they describe themselves as a "React" developer, or an "Angular" developer, I know they are not Senior. They might be Senior in that framework, but not Senior overall.
A Framework developer will never be a Senior Developer.
Frameworks don’t make you Senior because frameworks are only the icing on the cake. Not the cake itself. The tip of the iceberg, versus its bottom.
I would even speculate that behind the current epidemic of Impostor Syndrome among software developers, even Senior ones is not a lack of talent or lack of hard work.
It is weak fundamentals.
This is also why topics like debugging or performance optimization are a guessing game for most developers. They are not used to digging below the surface of the libraries and tools they are working with.
To become a Senior Developer you must not only understand the “What” but also the “Why” behind things.
A Senior developer would, for example, not only be able to build a React application. But they would also understand why React has been built in a certain way. And how it blends with the language it’s been written in (JavaScript/TypeScript) and the platform it runs on (the Web Browser).
The good news is that once you get the fundamentals handled, the level of everything will rise.
🚨 P.S. Are you looking to fast-track to Senior Developer with quality resources, feedback, and accountability? Click here to join our Free Community - The Senior Dev Academy. 🚨
6. Deliver End-to-end
The #1 reason why companies avoid Junior developers is that they need a lot of external help to get things done. External help means you will be bothering a Senior developer to get your stuff done.
Junior developers are considered “expensive” because they can’t deliver independently.
Instead, Senior developers can deliver end-to-end. Give them a bunch of requirements and they will figure out the rest. This doesn’t mean they are lone wolves, they are usually great at working in a team.
It doesn't mean Senior devs hack things quickly just to push them forward.
That’s not a “real” Senior.
And it doesn’t mean that they know every part of the software development lifecycle in depth.
But, Senior developers understand all the major pieces across the software development life cycle. And can contribute to each of them (frontend, backend, deployment).
If you are a Junior/Mid developer looking to level up, end-to-end delivery is one trait you need to put your eyes on.
7. Mental Models
One of the main things that sets Senior devs apart from more Junior ones is the amount of complexity they can handle.
Seniors can understand more complex codebases and requirements.
They can understand second-order circumstances. How changes in the codebase will affect performance, costs, and even the team.
And they do that not because they memorise every implementation detail. That's impossible because human memory is very limited.
They do that because they abstract the complexity of the code into mental models. These are simple ways of representing reality.
How can developers build quality Mental Models?
By looking behind frameworks and libraries and learning the design patterns behind them. There is a lot of noise out there depending on your tech stack. Things like SOLID principles, or MVC…
But I think the best way to start is by picking whatever framework you are working with and trying to look beyond the code.
Start asking yourself, why did the creators of the framework build it this way? Is it built on new concepts or is it just an implementation of age-old principles (which is usually the case)?
By answering these questions you will build your mental models on software development, and be able to handle more complexity. That’s one of the most effective ways to fast-track your growth to Senior Developer.
🚨 P.S. Are you looking to fast-track to Senior Developer with quality resources, feedback, and accountability? Click here to join our Free Community - The Senior Dev Academy. 🚨
8. Senior Developers Control The Story
One thing Senior Developers can do extremely well is lead technical discussions and influence other people around them. Be it business stakeholders, product managers or fellow developers, Senior devs know how to guide them in the right direction.
They do this using a mix of assertiveness, technical expertise, and communication skills.
Senior developers are also able to set strong boundaries.
They can disagree without getting emotional. They can stand up for themselves (and others) during meetings. They negotiate their salary aggressively.
And they tell their own story.
Senior Developers know how and when to draft a line in the sand and say "enough is enough".
If another developer starts blaming others during a code review, Seniors know how to stop them. If higher management tries to get into a developer’s work and micromanage, Seniors know how to push them back without damaging the relationship.
There is no step-by-step guide on how to become more assertive as a developer.
It takes repetition and practice. The first step is to stop saying “Yes” all the time. And to start trying to get your way in salary negotiations.
9. Long Term Thinking
Junior developers think for “now”. They think short term. That is true for their code when they take shortcuts. A Junior Developer will extend a piece of code without thinking about refactoring it properly or simply ignore testing and performance.
But Juniors also think short term about their careers.
This can mean job hopping too much or burning bridges. It can mean neglect.
Like not improving your skills or the way you sell yourself because right now your job is stable. Just to regret it six months later after getting laid off.
Part of becoming a more Senior developer is starting to think long-term.
The first way to do that is by changing your mindset. Most short-term thinking that Junior devs have is not caused by laziness but by self-doubt.
Deep inside they are still thinking whether being a developer is the right thing for them. Or whether they picked the right career.
These doubts stop them from committing long-term.
Good things take time, Senior developers know this and adjust their thinking accordingly.
And now with AI threatening the end of software development, this short-term thinking is more frequent than ever. Why commit to something anyway if it is going to be gone soon?
Trust me on this, it is only when I made a full commitment to my career as a developer that things started to take off.
I said, “this is it”.
I stopped looking outside. I told myself: this is my job now and it will be my job for the next decade so let me do it well.
I started investing in my skills because now I know they will pay off.
Even if you are not going to write code for the next 20 years, having a long-term mindset will bring you great benefits. Senior developers got to Senior level because they committed to their craft. If you aspire to get there, you should do the same.
🚨 P.S. Are you looking to fast-track to Senior Developer with quality resources, feedback, and accountability? Click here to join our Free Community - The Senior Dev Academy. 🚨
10. Excellence Is A Habit
I think it was Kent Beck who said the famous phrase "I am not a great programmer, just a good programmer with great habits". Habits are important because they stand the test of time.
Because any kind of knowledge you have about a JavaScript framework will sooner or later become obsolete. Technology changes. But your habits will stay with you forever.
The good news is that humans are creatures of habit.
It is not easy to set new routines in our brains.
But once we interiorise them as habits, we have an easy time following through. The best way to take advantage of this is to get whatever goal you have and break it into daily actions. Then turn those actions into habits through repetition.
For example, if you want to get better at testing, write one unit test every day.
If you want to be more prepared in the daily meeting, and think clearly, keep a journal. If you want to find a new developer job, and you have to send 100 applications, send 10 applications every day.
Set up new habits and your progress towards the Senior level will be constant and steady.
11. Protect Your Most Important Asset
Being a Senior Developer means thinking long-term not only about your code and technical decisions but also about your health.
Because health is wealth.
I talk about this again and again in my videos.
Developer jobs are extremely sedentary. You spend most of your day sitting in a chair in front of a computer. That is very bad for your health.
Then, there is all the trash food, like chips, soda, and candy in the office. This means unless you make a conscious effort, it will be hard for you to stay healthy and in shape.
But if you want to have a long and productive career writing software, and you don’t want to end up with back problems, diabetes, or even something worse, you need to start taking care of your health.
If you want the golden eggs, don't kill the goose. If you want more productivity, take care of yourself first.
This doesn’t mean you have to start hitting the gym 5 times a week.
Or go on some crazy diet. But do sports at least 2 to 3 times a week. You can hit the gym, go for a run, or do a team sport. Right now I am doing
On the diet side, cut on sugar and refined carbs. Don’t overdo it with the meat either.
Consider your mental health as well.
Ignore advice like “eat, sleep code, repeat” and build a life outside of work.
Start a new hobby. Reach out to a friend. Take breaks.
In the short run, you might progress a bit slower. But in the long run, you will be able to stay in the game for a longer time.
🚨 P.S. Are you looking to fast-track to Senior Developer with quality resources, feedback, and accountability? Click here to join our Free Community - The Senior Dev Academy. 🚨
12. Close The Circle
Finally, Senior Devs understand how karma works. They know that no matter how hard they work, or how smart they are, dozens of people helped them on their way to the top.
This doesn’t take away their merit but acknowledges other people as well.
So they close the circle.
They help other developers out. And they do it without expectations.
Not because it might get you a promotion. Or status, or admiration. They do it because it is the right thing to do.
Even Kobe Bryant found the time to mentor young kids and get them into basketball. You can also find the time to help a fresh developer out.
Helping someone who is just starting out will give you back part of the spark. The passion and curiosity that a beginner feels when they see things for the first time is so contagious.
Another thing you can turn into a daily habit!
Okay, this is it. Put in place these 12 traits and you will fast-track your growth to a Senior level and beyond.
Moving forward, here are 2 things I want you to do:
1. What are some traits you’ve seen in Senior Developers that you think we should add to the list? Comment below, and I will try to answer all your comments!
2. If you are an ambitious developer trying to level up and you are searching for a community of like-minded people, click here to join our free community for JavaScript developers looking to fast-track to Senior level.
Top comments (36)
Where can I find those junior devs? I wish that anybody would do tests except for some old-school nerds.
My skills, traits and habits that I didn't have as a junior:
What I mean: it's easier said than done to focus, to take your time, to say no, to have nothing to prove once you have reached some level of experience, but proabably more importantly, a certain level privilege and safety. It makes no sense to study quotes of rich people like a late Steve Jobs or Warren Buffet if you're a young student struggling to pay your rent.
Mentioning Kobe Bryant, he was already cool as a rookie, and now he is giving back something to the community. He is a real role model!
Testing is only useful if the tests actually catch bugs. Tests are not useful when they force the developer to fix existing tests, everytime new functionality is added even though the new functionality isn't broken.
All teams I've worked in that had a big emphasis on testing, just did half of the amount of work building features, because the other half was wasted writing and updating tests that never actually flagged a bug and the software they delivered had just as many bugs as "untested" software that I have worked on.
TDD sounded fun 10 years ago, but it failed to proof itself.
Nowadays I prefer to write a test, only when a bug occurs that we didn't get notified about and then only write test(s) to catch that specific kind of bug.
100% @brense - I can emphatise. Tests are a means to an end, not an end on itself
The real benefits of Tests is when they are used on CI/CD when submitting a PR and before deploying the project.
Not if they hold up deployment for no good reason, like implementation changes. Automated testing in CI/CD pipelines can become a massive bottleneck, bringing entite companies to their knees. Most teams CI/CD pipelines work better if they just do a few unit tests on critical business logic and get someone to do functional or acceptance testing.
Now Kobe is giving back? Please elaborate how so.
This was such an informative read. I'm just starting out, currently on a bootcamp mid career switch and hearing from a senior Dev like this is just what I needed to read this morning. Interestingly TDD is a huge part of my learning at the moment and your section about this was eye opening.
Thanks!
Best of success on your journey @gruitt and thank you for the feedback
Very nice piece of article. Thank you for sharing your awesome knowledges.
Thank you for the feedback @arafatweb
One question here: Does a senior developer have to strictly adhere to architecture guidelines compared to a junior developer?
I'm curious to know.
I would say no. Guidelines are guidelines, not absolute rules.
Also, guidelines are tools. Sometimes they apply, sometime not. When you have a nail, you use a hammer. When you have a screw, you use a screwdriver.
Junior find a golden hammer and try to use it everywhere.
Intermediate know when to use a hammer and when to use a screwdriver.
Senior know that, sometime, using a hammer to nail a screw is better. (when nailing a screw in chipboard wood, fibber will prevent the screw to going out, making it more robust than using a simple nail or screwing the screw 😋).
+1
One of the biggest difference between senior and juniors is that seniors can improvise where as junior need stricter rules to follow. The more senior someone is, the more they can make good decisions, faster and with limited information. Seniors will take architecture guidelines as recommendations but always take the context in consideration before making a decision.
Very good article! Also, (most) juniors learn only from their own mistakes while mid/senior also learn from the mistakes of others
Impressive
Very interesting read, thanks
Great write-up, thanks for sharing
Thank you for sharing this, I can relate to most of the points.
You are welcome @keshavkishor
ju.edu.jo/Home.aspx
It all makes sense, thanks for writing it down!
Thank you for the feedback @luckyshuii
I wouldn't say that there aren't seniors who focus on one or two frameworks/technologies. If someone puts react in their title it's could be because they are advertising themselves to potential employers. I know when there's a technology that I want to use in my next job, I make sure to highlight it a bit so that I get the attention of employers who are doing stuff that I am interested in.
There are also all of the devs who are specialists on a specific technology. Can't tell you how many times I've run into a dev who made their career on a framework like rails or phoenix and that's what they want to continue doing. I say this as someone who has been in the industry for almost 25 years. While I consider myself to be a polyglot but it's also valid to be a master of one specific ecosystem/technology/domain. What's important is that these devs are open to learning something new should their job call for it.
Anyways, just wanted to throw in my two cents; good article overall.
Interesting read, lots of valid points, but there's no clear cut factor that determines if you're a senior or what you need to do to be one, but having a mentor that can help you in your journey is a very good way to make progress.
Thanks @dsaga - 100% agree, is much easier if you learn from someone that has been there before
Generally, yes, but I definitely wouldn’t say always. Sometimes devs spend too long overthinking or over-architecting when you can find answers faster by just building.
For juniors aspiring to excel in software development, learning from senior developers is invaluable. Senior developers exhibit traits that juniors can master to enhance their skills. These traits include effective problem-solving, strong communication, mentorship, continuous learning, and a deep understanding of software architecture. Embracing these qualities will undoubtedly contribute to a junior developer's growth. It's like being a "Door Bell Geek" – always ready to learn and adapt, just like a doorbell that responds promptly.
Some comments have been hidden by the post's author - find out more