Three years ago, I faced a brutal truth.

Up to that point, I had been writing dozens of lines of code. But, when asked to solve specific technical issues, I often realized I would get stuck on basic things.

The harsh reality was I missed fundamental software knowledge.

You know what I am talking about. Is that code review when everyone looks at you for and answer and you can't find the words to describe the code you've spent 15 hours putting together.

Or the shock of going back to libraries you use every day (React Hooks, Redux, TypeScript) and realizing you can barely understand how they work under the hood.

In those moments you are faced with the bitter reality of being a software developer today: technology advances too fast and we are losing the fight against time.

Yet, unlike the processors in our laptops whose processing power only keeps growing, our brain, a legacy from our ancestors is limited. It can only process a limited amount of information.

So, back in my writing code days, I asked myself: "Is there a better way to master software development?"

I Spent The Last 4 Years Studying The Best Methods To Improve Your Technical Skills As A Developer, Taking Hundreds Of Online Courses And Experimenting With Different Tools

Looking back at my day job as a full-stack developer and my learning activities I started noticing some patterns. If I wanted to get to the senior level and accelerate my learning curve I had to fix the following:

• I spent 14 hours a week "learning" on Udemy or YouTube (getting little in return)
• 80% of my time was looking at the same kind of code
• I threw away most of it because it would quickly change after a couple of days

What I wanted is a System that could help me become a better JavaScript developer and a better software engineer.

To design such a process I asked myself the following questions:

• What are the things that don't change in software development?
• Can my lack of a "Computer Science" degree be turned into a strength rather than a weakness?

I wanted a system that could:

• Allow me to understand the specific technical gaps in my knowledge (so that I can focus on what matters)
• Build strong fundamentals so my programming skills stay relevant for the decades to come
• Understand the big picture and make the transition from "coder" to "software engineer" faster

Fast forward to now. Every week I get Linkedin messages from developers asking me how can they set up such a system for themselves to get to the mid/senior level? This would have been unthinkable 3 years ago when I was barely able to deliver on my JavaScript code.

Or developers asking for my mentorship services, when years ago I was the one desperately looking for a mentor. This allowed me to leave my position as a full-stack developer and dedicate myself fully to mentoring software developers that want to get to the next level.

As a result of my learning System, over 110 developers all over the world are now touching the mid/senior level. With 9 of our mentees getting past senior-level already. My inbox is full of thank you messages.

I noticed most articles and tutorials focus on how to learn new frameworks, but I couldn't find much about how to get better at software fundamentals. This is strange as in the end our skills as developers are only as good as our technical foundations. These principles could help thousands of developers out there yet most of them are hidden behind unreadable programming books and indecipherable technical jargon. Yet is only by sharing that we can improve and refine that knowledge.

In this article, I will share my top learnings on how to get to the mid/senior level faster as a JavaScript developer. This is not an easy read, use the list below if you want to jump to a specific point:

1. You are already ahead of the curve
2. Find the gaps
3. Do more with less
4. Master the fundamentals
5. See beyond "the code"
6. Free resources to help you close your technical gaps effectively >>

Now let's get going with the first mindset shift you need to go through…

Learning #1: You are already ahead of the curve

The good news is that if you have already been writing code for a while, you already have a considerable advantage.

"According to the 20th edition of the State of the Developer Nation report, there were 26.8 million active software developers in the world at the end of 2021. That is ± 0.34% of the world population."

It doesn't matter how you got here.

Maybe you are self-taught and you have spent hours on side projects and courses. Or maybe you did a Bootcamp and invested months in perfecting your programming skills. 

Regardless, because you have already started you are already ahead of everyone who still doesn't code.
Let's do the math; to deliver a simple React app, you need to spend a few hundred hours coding. On top of that, at your job you have probably seen a lot of code.

The keyword here is "integration".

Yes, instead of learning new things what you have to do now is to "integrate foundational" software development knowledge into your existing skills. This mindset is crucial as it will allow you to stop thinking about the senior level as something you will get one day but as something that you can start working towards right now.

The majority of developers out there compare themselves to the senior developers in their teams. What happens after? Impostor Syndrome kicks in, they start feeling less and less confident in their technical skills and stop doing anything to improve them at all.

Most developers fail to see the dozen on people that are behind them in the learning curve. And the hundreds of things they already know. 

As a software teacher, mentor, and coach, my job is to put things in perspective and help you make the most out of what you already got.

Now that you understand the issue, let's move forward with the most fundamental mindset shift for getting to the next level…

Learning #2: Find the gaps

The idea that you must first understand where you stand before you start the journey has been perpetuated since the beginnings of modern history.

For example more than 300 years the British Navy had the most sophisticated ships and the most experienced sailors. Yet they kept sinking.

Why?

Because they could not find out exactly where they were on the map (more exactly the longitude).

Latitude miscalculations caused the loss of thousands of human lives.

It wasn't until John Harrison developed a reliable chronometer that the problem was solved (he was a self-taught carpenter and it took him around 40 years to actually get it done).

Just like the sailors of the British Navy, most developers today have access to countless resources.

Yet, many of them are stuck.

Because they are not able to answer one simple question… "What is my technical level?"

Until you figure that out, it doesn't matter how many hours you put in. Or how many side projects or online courses you start, because…

"If you don't know your technical gaps, you are shooting in the dark."

The best way to start a journey is by first understanding where you stand and where you want to get to. This is the foundational step in reaching mastery and if you get it right, the rest is just a matter of execution.

After months of looking for a reliable method to assess a developer's skills, Bogdan and I could not find any solution that worked. So we did what any smart developer would do… We've built our own!

To make it even better, we have opened it to the world, so you can also understand where you stand right now as a developer (check the links at the end of the article).

But, even if some developers have a rough idea of their gaps, they still struggle.

That brings us to the next foundational learning in this article…

Learning #3: Do more with less

The whole exercise of finding your technical gaps is meant to show you the missing parts in your knowledge. However, if you don't know what to focus on and start taking action, that knowledge is literally worthless(it can even hurt you).

At this point, most developers get sidetracked. They have the "school" mentality. Try to learn everything at the same time. A recipe for burnout, confusion, and a short developer career.

Here is how to think about it - your value as a developer is not in your knowledge. As technology changes, the way we implement things will change. Libraries will change, frameworks will change, even languages will change. If you focus on those things, you will be trapped in the "framework hamster wheel".

When most developers try to improve their skills, they start 7 different online courses and 3 different side projects. If that is your to-do list, good luck! You will never finish.

Meanwhile, in the market, the only thing that matters is your ability to get things done. To ship clean code, to build high-quality software. Quality means sacrifice. It means to stop asking "how much?" and start asking "how deep?".

In software development as in life, the skill to develop anything of value is prioritization. Prioritizing what skills you should learn and what skills you should forget about. You prioritize based on value, not current importance.

What is value in terms of technical skills? That brings me to the next point…

Learning #4: Master the fundamentals

Let's go back in time for a moment…

Remember when you were building sandcastles at the beach as a kid? Only to come back after a few hours and see the whole thing being washed away?

You also probably remember as well the issue was with the foundations. Turns out sand doesn't really stick together for long particularly if you add water.

This is exactly what most developers are trying to do these days. They learn framework after framework, constantly adding new things on top of weak foundations.

But, no matter how tall the castle is, if the foundations are built of sand, they will be washed away in a matter of seconds.

It is a well-known fact that true masters in their fields focus on principles, not procedures. In software development, fundamentals are the things that don't change. 

For example, no matter how many new shiny JavaScript frameworks we will see out there, the foundational piece will still be a JavaScript bundle that gets shipped through HTTP to a browser.

Effectively understanding the protocols and processes behind that process will allow you to stay on top with minimal effort. That is the power of fundamental knowledge, not just some implementation details that keep on changing.

I know this is the complete opposite of what the "community" is doing. With most of the Twitter influencers feeding you the new tips and tricks.

And while most developers out there are obsessed with the latest JavaScript framework, VS Code plugin, GitHub Co-pilot… Some smart developers are looking somewhere else(and if you want to make it in this field, you should do the same).

They know, that no matter how many new things you add on top of a weak foundation will lead to a disastrous crash. To gain complete confidence in your technical skills, you must first study the fundamentals.

That brings us to the following point…

Learning #5: See beyond "the code"

Researcher Lindsey E. Richland studies cognition and learning, particularly how students all over the world study mathematics.

The difference between the students that really made it and the students that didn't? Was it the textbooks that were different? Or the teacher?

You would be surprised.

It turns out the students that struggled were learning mathematics as a set of instructions. In the exams, they were relying on memory in order to pass.

On the other hand, students that thrived had one thing in common. They were able to see mathematics as an interconnected system. They were able to see the full picture and make the right connections when evaluated.

Sounds familiar?

This is unfortunately the way software development is being taught today. Watch video tutorials. Code. Repeat.

No wonder most developers struggle.

When you learn things like this you become completely tied to the code you are working with. Once you are pulled out of there, you will freeze.

This "monkey see monkey do" type of learning will never get anyone to senior level because is the opposite of what a senior developer should do.

Past the Junior level, imitation stops being an effective learning strategy. (Image Credits: Shutterstock)

When you learn programming as a set of instructions it is easy to miss the big picture.

Yet, in real life, if you can't get it to production, your hands are tied. You will always depend on a senior developer to help you out and won't be able to deliver end to end. It's a confidence breaker.

Seeing beyond the code means understanding that there is a lot more than coding when it comes to building software. It means being able to see the full picture and being able to implement all necessary steps for your code to get to production.

From testing to integration and deployment, you will be able to navigate the complete software lifecycle. You must be able to deliver end to end.

How to make the most out of these learnings:

Even if the principles behind this System have been tried and tested with dozens of developers already, you will face some common challenges when you start implementing them. Here is how to tackle them:

• Speed: "The seniors at my job have many years of experience. Even if I implement these steps, I don't think I will get there much faster." - warming up the chair for 12 years does not make you a senior developer. Experience matters, yet we can be more effective in your way to gain experience. Do half of the above and come back to me in a few months.
• Lack of time: "After a whole day writing code at my job, I don't have any energy left for learning" - when you put such a system in place you will only need as little as 5 hours per week (and half that time can be done on the job)
• I have a lot on my plate now: "Yes, I want to really push myself and get to the next level but I have some things in my personal life coming up right now, I will do it later" - guess what? We all do. There is always something out there to distract you from taking action. When is it going to be the right time for you to put what you want first?

Do you know what makes the difference between the developers that really make it and the ones that are just getting by?

After being a developer myself for the last 8 years and helping 110+ other developers get to the next level I can give you an insight.

It is not a Computer Science degree, nor starting to code at an early age, nor innate talent, nor genius, nor fancy knowledge.

Is that great developers live in the NOW.

If the code is not clean, they clean it now. If the pipeline fails, they fix it now. If they feel underpaid, they negotiate now. If they feel they have gaps, they look for answers now. They find the person that solved it and they get their advice now.

The good news is that you can start right away. I have put together a series of resources for you to get started. Follow the steps below to get access:

1. Find out your technical gaps with our free technical assessment by clicking here
2. Watch the technical training where you will learn how to get to the mid/senior level faster by improving your technical skills effectively using a 5 Steps System

If you want to gain complete confidence in your technical skills, get to the mid/senior level faster, and earn more as a developer I invite you to watch our free training and reach out to me.

We will understand exactly where you stand right now technically as a developer and draft a step-by-step technical roadmap for you to get to the next level.

PS. This is the first article I am pulling out in 2022 (a lot more to come in the pipeline). To make sure you get such insights you can subscribe to my YouTube Chanel.

PS. Did you watch that training yet? :)