I’m primarily focusing on LVEC right now, and focusing on creating content for other self-taught web developers. However, when I find some free time… I still love to code.

The quality of my coding time has evolved over the past year. It has changed from a sometimes nerve-wracking, sometimes victorious experience… to something almost resembling a flow state. I’m able to envision big-picture problems without being overwhelmed by every step in between. It’s kind of miraculous.

I’m not sure what this means for me in the long run, but a developer friend suggested this week that I may be an “advanced beginner”. Of course, I had to find out what that really meant. And in order to understand the “advanced beginner” experience, I had to first understand the overall “scale” of developer competency.

If you’re not there yet, please don’t even worry about it. Obviously, it took some time and work, and time is simply something we can’t speed up. There are very effective ways to absorb more information in shorter periods of time, but that’s a post for another day entirely.

Doesn’t that seem a lot more effective, and simple? Competency scales aren’t supposed to tell you which skills you should have, they are supposed to be indicative of how comfortable you are with those skills.

So, let’s take a look at the experience of the Beginner developer in any particular area of web development, and how they evolve into/within their respective areas.

The Beginner Developer

Ah, to be a beginner. When we first begin teaching ourselves web development, everything is a wild success.

From our first “Hello, World!” to our first function, we pick up basic skills at a remarkable pace. We feel like we’re accomplishing a great deal, and this is for good reason: the beginner level is supposed to be easy. This is an excellent example of an equally excellent learning tool at work: engagement and curiosity are high, and small, consistent successes create high self-confidence.

Regardless of the language, Beginner developers can get caught in a rut of simply learning by following tasks, without attempting to understand the bigger picture. Seeing how everything links together will move you out of the Beginner category more quickly than if you tunnel-vision on completing tasks.

Likewise, a Beginner developer with a strong background in Math or Science may be able to grasp onto fundamental concepts of programming, like advanced logic statements and data structuring, faster than their peers. (This wasn’t me at all, and I still made it past this point, so have faith!)

Somewhere just past our first functions in the Beginner level, increasingly more is expected of us. We are challenged to think like programmers, and actively focus on solving problems. This is often where self-taught students drop off, if not properly supported and aligned with the right mindset.

Advice to graduate:

• Challenge yourself by trying to write your first methods, and learn the concept of Object-Oriented Programming early. It will help you later on in your journey.
• The Beginner stage is the ideal time to hone your Google-fu. Being able to find the answers you need is more important than knowing them off the top of your head.

The Advanced Beginner Developer

”I could build that!”
—every advanced beginner ever

If you observe this thought crossing your mind, you may be in the Intermediate developer stage. An awesome idea for a web or mobile app comes up. Perhaps in conversation… or you’re alone in your car, or in the shower. It can’t be that difficult, right? And even if you don’t know what the hell building that web app would involve, you feel confident enough in your Google, MDN and StackOverflow search skills that you can probably tackle it.

Advanced beginner developers are often plagued with wild optimism, without taking into consideration the underlying complexity of the task at hand. As Dain points out, “the difference between a senior/mid-level and advanced beginner developer is that advanced developers just don’t think that way.”

For me, I believe I was starting FreeCodeCamp‘s Intermediate JavaScript Algorithm Scripting module when I realized that things were getting kicked up a notch.

I was gradually moving off of performing simple tasks, and being encouraged to plan out my approach more before coding. This was my introduction to structuring my code and planning out my code before writing it. I no longer had to focus on how to write the code, because I had the tools in my toolbox, and getting it to compile was no longer an issue. My focus was now on ensuring that I was solving the problem in the most effective manner.

The Advanced Beginner knows why something went wrong, and what’s going on in the language, computer, and compiler to cause the issue. Learning how to debug your own code, and others’ code, is an important milestone of this stage.

One of my favorite podcasts, Start Here: Web Development, discussed this very topic on their episode titled “How to Be a Successful Developer & How To Overcome The Advanced Beginner Syndrome“. Yes, they refer to it as a “syndrome”… because of some of the pitfalls that can also come with growing out of learning how to code, and into thinking like a programmer.

Primarily, the Advanced Beginner level is considered dangerous because you can easily get stuck here.

Why we get stuck here

Let me paint a picture. You’ve committed to teaching yourself to build web apps, and it’s been perhaps a few weeks, months, or even a year or more. You have consistently hammered away at programming tutorials. There is no time period that needs to have passed to get here.

Upon reaching this phase, a lot of people wish that they could graduate from being an Advanced Beginner to an Intermediate. However, they stop programming, or decide to stick with projects that they are comfortable with. Compared to the Beginner phase, where everything we are handed is teaching us something new, Advanced Beginners may become more concerned with using what they know.

Often, this is perpetuated by complacency or fear. If you began freelancing during this phase, for example, you may be afraid that taking a project outside your knowledge comfort zone will reflect poorly on you.

We read articles at this point that are increasingly critical of Advanced Beginner-level code, and may become discouraged, thinking that there is an uncrossable chasm between us and the summit to Intermediate-level skills. So they just stop trying.

How to get unstuck

Getting unstuck from anything is hard. It ultimately requires understanding of the reason why you got stuck in the first place.

If you stopped writing code, or find yourself writing the same type of code with no variation in difficulty, challenge yourself to complete one small project that requires knowledge you don’t currently have.

Identify topics you’re not comfortable with. If you don’t even know what it is, even better! Google everything. The process of doing this will engage you again.

Maybe it’s a complex single-page app using libraries you’ve never word with before. Your brain will adjust to learning mode rather than pure execution mode. Follow your natural curiosity, affirm yourself regularly, and know that you are taking charge to break out of stagnation!

Learn another language. Choose one closely related to your original language, so there’s enough familiarity to provide you with the confidence you need to flounce through the basics. Justin James wrote for TechRepublic on the topic of moving from an advanced beginner to intermediate developer:

Learning a language consists of three realms of knowledge: the syntax, the built-in operators and libraries, and “how to use it.”

The first two are easy; I think that an experienced developer can pick up enough of a language’s syntax to maintain code in 30 minutes to a few hours depending upon the language. The operators and libraries are just a matter of slowly accumulating knowledge and being willing to check reference materials until you memorize what you need to know.

But it’s the third item — “how to use it” — that can only be learned over months of working with a language and that’s where the real magic happens. I suggest doing a project that is well suited for that language and doing it in that language’s style.”

Somewhere during the progress of learning your new language, you may find that you’re once again thinking differently about programming. Enter the Intermediate developer stage.

The Intermediate Developer

Once you’ve continued working through the Advanced Beginner phase, you will eventually find yourself at the Intermediate stage. Intermediate-level developers have typically worked with more than one language beyond HTML and CSS, and are able to flesh out an idea from understanding the project, to inception and partial implementation of the solution.

Needing to look up at this point is totally natural. Being someone who is self-teaching, you are once again in control of what happens beyond this point. Knowing where and how to find your solutions is incredibly important at any stage, but you may find that your questions change at this point, reflecting a deeper understanding of the process.

Rather than “how do I <insert end result here>”, your questions may be more specific, indicating the steps you took to get to the point at which you currently are. Other developers pick up on this on sites like StackOverflow, and your answers may be lengthy and dense, because you’re expected to have some idea what they’re talking about in their proposed solution.

By this point, you should be comfortable with debugging your own code, and reading others’ code for ideas. If not, there are plenty of resources to utilize on the internet, including Udemy courses like Anthony Alicea’s JavaScript: Understanding the Weird Parts (I highly recommend this course for anyone looking to gain in-depth knowledge of JavaScript). Generally, a deep breath and a walk tends to also help, taking your head out of the code for a while.

Advice to graduate:

• If you haven’t already, try open source contribution. Apart from honing skills in reading others’ code, you will make invaluable connections to further your education. Alaina Kafkes, blogger and supporter of women in tech, wrote a great introductory post to the world of open source.
• If you don’t have mentor by this point, get one! Developers in the Intermediate stage are prime picking for recruiters from all areas of the industry, and it can be overwhelming to figure out what you want to do with your programming skills without some real-life guidance.

The Advanced Developer

You’ve worked tirelessly to learn web development over the past years. Give yourself a pat on the back — if you’re here, it’s because you are truly meant for what you do. You’ve likely had the opportunity to freelance or work for a company in a developer role, and may even hold a Senior title. Don’t let this go to your head.

Take a moment to check in with yourself. Are you fulfilled in your current role? Are there areas unexplored that could give you greater satisfaction in your work? Areas of your chosen languages that you still don’t quite understand? (Understand that this could be because they are not commonly used, but having a working knowledge of them is like flashing your Advanced Developer badge)

Beginner-level developers are highly impressionable and have a tendency to pick up bad habits from more advanced developers. By this point in your career, you should know how to evaluate others’ development habits, and determine if they are a good fit for you to adopt. You should have a network of developers within reach, and having your code questions answered or validated tends to be easier than up until this point.

As your skill level continues to climb, be mindful of your ego. Helping those under you is the best way to support your origins! Consider taking on a mentor of your own at this point. Teaching others is inarguably one of the best ways to learn.

Advice to graduate:

• Be a mentor to others.
• Contribute your knowledge to those under you.

I’m personally not going to get into Expert levels, because I’m so far removed from that point… and honestly, I don’t truly know anyone I’d describe as an expert developer. Most developers I know are between the Beginner and Intermediate stages, myself included. It’s safe to say that beyond the Advanced level lies years of improving skills, doing check-ins, keeping up with changing industry standards, and passing on what you have learned to others.

In summary

The most important point that you could learn from this article is thatlearning web development is an ongoing process. You cannot come into this thinking you will be an expert overnight, or that you are an expert because you’ve learned one language.

Being open-minded and receptive to constructive criticism, while standing up against undue criticism for being unskilled, is imperative.