One of the most difficult things about getting started in a new career as a developer is figuring out exactly what you should be learning – and then translating that into an effective plan.

There are so many resources out there for learning, so lack of information is not the problem.

The problem is two-fold:

First, it's hard to gather all this information and turn it into a cohesive plan for systematically learning what you want to learn.

Second, it's hard to figure out how to take all these resources and actually learn from them instead of just being stuck in tutorial hell forever.

The struggle is that we get sucked into the step-by-step nature of tutorials and courses and it can be hard to break out of that and do our own thing without having plan to follow.

This guide is meant to help you learn how to put together your own learning plan so you can utilize tutorials and courses while still being able to break out of the set path and begin to forge your own.

It is impossible to genuinely learn to code by just following tutorials and courses over and over again.

At some point you have to step out of the comfort zone they provide and do something on your own.

My hope is that this guide will serve as a transition aid by guiding you towards creating your own learning path instead of telling you exactly what to do.

The Psychological Trap of Step-by-Step Paths

Before we get into the practical methods, we need to talk about why people get stuck in tutorial hell, and how to get out of it.

For most people, the process goes something like this:

You go through tutorials, feeling great. You are breezing through the tutorial, building something from scratch.

Maybe you run into a few small bugs, but nothing you can't work through really quickly.

You go through a few of these, building some small projects along the way.

Then you go to start building something on your own and immediately hit a wall.

You can barely get the project started before you feel like you forgot everything you just learned.

You will feel like you are starting from zero. Like everything you just spent time learning went out the window.

You feel like you didn't learn, so you find more tutorials thinking you need them to learn more before you build something on your own.

And the cycle continues.

In reality you stopped struggling too soon.

The learning doesn't happen only in the tutorials. The learning happens in that moment when most people give up and go back to the tutorials.

That struggle. That feeling like you didn't actually know anything. That's the first step of the learning process.

Don't run from it. Lean into it.

It's a lot harder to do. It's comfortable and easy to slide back into the tutorials because completing them feels good. It makes you feel like you are learning.

But it's a dangerous trap to fall into because the real learning happens as soon as you stop being comfortable and start struggling to build something on your own.

So before we get into the practical steps of designing your own learning plan, please understand this and be ready for it.

There is no shortcut, no easy step-by-step solution. You just need to accept that you are going to struggle and be confused and not know what you are doing.

That is part of the process.

That is where the real learning is taking place.

Embrace it and push through it. The rewarding feeling of having built something from scratch that doesn't exist anywhere else is worth it.

And it's what will stand out to potential employers and clients when you're trying to find work as a professional developer.

How to Decide What to Learn

I like examples and seeing specific implementations of concepts. So in this guide, I'll talk about a concept and then give an example of me going through the process of designing a learning plan for a tech stack I've been interested in for a while: Blitz.js.

In order to decide what you want to learn, you can take a few different criteria into account.

These will vary depending on where you are in your career.

If you are just getting started, I recommend choosing a stack with high potential for employability.

Right now I would recommend React for that.

If you are already familiar with React I would go for learning some Web3 and blockchain.

I'm 7 years into my career and am to the point where my main interest is exploring different emerging stacks that can make my job more efficient. For me that means I am interested in Blitz.js.

I love the idea of having a stack that has the same philosophy as Rails but is built on top of React and Next.js.

You may just be getting started and so you are primarily interested in learning how to build things with React so you can get your first job.

This will vary for each person, but the building blocks of that learning plan design will be the same.

Get Some Initial Exposure to the Tech Stack

The first step in learning any new stack is to simply be exposed to the basics of how it works. The best place to start with this is the official getting started tutorial provided by the stack.

Most stacks will have something like the getting started tutorial for Blitz or React.

But if they don't, do a Google search for a beginner's tutorial for your stack.

After you go through the official tutorial glance through the docs. Don't try to read the docs straight through, just browse and glance to get a high-level overview.

Going through the tutorial will have the added benefit of exposing you to some of the ecosystem of your stack.

Almost everything you use will need at least some sort of other tool to work with.

Going through the tutorial and docs will help you be exposed to those initially, which will help in the next step.

Research the Supporting Components

Now we have our initial exposure done. We are familiar with the basic concepts of the framework and at a very high level know how it works technologically.

The next step is to research the different supporting components we might want to use in building out a complete project.

So in looking at Blitz, I noticed that they have recipes for adding certain functionality to Blitz apps.

For example, they have a recipe for Tailwind CSS, which is a UI system I've used before but would like to be more proficient at.

So I'm going to add that to a list of supporting components.

Don't worry about learning it yet, just keep a list of other supporting tech you want to look into.

I'm also going to add Prisma and Render to that list, since Prisma is the database system that Blitz uses and Render is one of the recommended deployment tools.

That's all I'm going to put on my supporting components list for now, but this is an unusually short list because Blitz is designed to be an all-in-one framework.

If you are learning something more foundational, like React, you could have a potentially never-ending list of supporting components.

For now, just keep a running list of different tech you would like to learn more about and categorize it.

For example, if you chose React, you might want to learn Chakra UI, Gatsby, and Strapi CMS in order to build JAMstack sites. Those would be good things to add to a list of supporting components.

Remember, we aren't diving into these yet, as that would be too overwhelming. We're just making a list to research over time.

Build a Complete Project

Now it's time to find a course or tutorial that builds a complete project from scratch using your chosen technology.

This is to get introduced to how everything fits together and start understanding how the different components you have been researching all work to make something valuable.

Try to find something that utilizes some or all of the components you have been finding.

Don't worry if you can't find one that uses them all, that's fine. We really just want to find a source of learning that will allow us to see how this stack looks when building a complete project.

Google is your friend here, as are any groups or social media sites you are a part of.
I searched 'blitz complete project tutorial' on Google and found a few that look promising.

If you chose React as your stack, I highly recommend the courses from Wes Bos and UI.dev. They both focus on creating full projects and will be great for the kind of learning we're talking about here.

Build Something from Scratch

This part is important. After that complete tutorial, stop. Don't do any more tutorials or courses until you build something from scratch.

Now we get into the hard part, but the part where the real learning takes place.

Take everything you have learned and apply it to building something on your own.

Use the resources as references, but only in the context of building your own thing.

Remember the trap we were talking about earlier. Don't fall into it.

Keep pushing forward through the struggle and work on your debugging and research skills.

Use the familiarity with the different tools you have been researching to slowly piece together a project from scratch.

Make it complete. Add a UI framework so the design looks relatively nice. Add some CI/CD and automated Git-based deployment. Make it usable.

If there are some tools you wish the tutorial/course you found had used, or even some you are interested in learning more about, use those instead.

Make your project different from the course so you can learn how to piece things together own your own.

Write some tests, add some CI/CD workflow, and get it deployed.

For example, Wes Bos has a Master Gatsby course that utilizes Sanity CMS and custom scoped CSS.

Maybe you are interested in building JAMstack sites so you decided to follow that course.

After that course you might try building your own JAMstack site using Tailwind and Strapi instead.

The point is to build something unique and on your own, referencing the content you have been reviewing up until this point as you need it.

How do you come up with ideas for things to build? Try to keep it simple and solve a very small problem you are specifically facing.

If you don't have a personal site, you could learn the JAMstack to build it.

Maybe one of your friends or family has a small hobby or business they've been wanting a website for, there's another great use case for JAMstack.

Maybe you've been struggling to make a certain change in your life because of a lack of tools, so you can build a tool to help solve it.

One of my first personal projects was an app I made called TinyThought. It was a simple Laravel app that helped me journal one sentence per day so I could build the habit.

To learn Blitz I'm thinking I might do something similar to track my strength training progress.

I'm implementing Tiny Habits methodology in order to be consistent with doing pushups, squats, and chin-ups.

So I might create a simple tracking app that allows me to keep track of which days I completed the habit and how many of each exercise I did.

Write About It

Then write up how you built it.

The writing is important.

Writing will solidify your learning and help you get clear on your process more than anything else.

To really solidify learning something, teach it to someone else.

So as you are going through the process of building your custom project, write down everything you are learning, challenges you are facing, and your process for building.

You can create a series or one long, in-depth post and publish it to DEV.to, freeCodeCamp, or your own blog for other people to learn from.

If you prefer video, you can make some videos and put them up on YouTube. The ultimate form of the content doesn't matter, as long as you are teaching the process while making it as clear as possible.

Teaching other people is by far the best way to solidify your own learning and make sure you actually understand what you are doing.

Rinse and Repeat

Now rinse and repeat this process for every new piece of tech you want to learn.

It will solidify your knowledge and build your portfolio and online presence at the same time.

Once you have this process down, it will get easier and easier every time you want to learn something new. I highly recommend you follow a process similar to this when you want to learn a new stack.

The more you do it, the more you will learn and the more your portfolio and proof of skill will grow. This is how you can leverage learning to code into work as a professional developer.

For more actionable information like this on how to start and grow a successful dev career, check out my free 10-day email course, Launch Your Dev Career. It's a step-by-step guide to landing your first job as a developer.

We go over how to build an online presence, networking, building an impressive portfolio, and more, all designed to help you launch and grow a successful, fulfilling career as a developer.