Search [Enter] to search. Click anywhere to close.

April 19th, 2022

What To Learn After JavaScript

If you’re new to the web development realm, there’s a good chance that your path may be starting to look something like this:

  • Learn HTML & CSS
  • Learn JavaScript

But what comes next?

It can of course be a little bewildering to figure this next step out, there are so many languages, frameworks & tools to grapple with!

So if you’ve been wondering what to learn after JavaScript – worry not, we’ll break down the (many) various options available to you at this point.

This article will focus specifically on the route a full-stack developer may want to take, so we’ll cover both frontend and backend technologies in this article.

With that said, let’s begin!

1. Learn React, Vue or another frontend framework of choice

Native JavaScript is most definitely an important staple for web developers to acquaint themselves with, this much is not debatable.

However, once you’re familiar and comfortable with basic JavaScript (along with it’s many quirks), you’ll want to look at applying your new-found knowledge to real world situations and projects.

This is where a library (or framework) like React or Vue would come in extremely useful. This is perhaps the most obvious choice with regards to what to learn after JavaScript, and for good reason.

The role of JavaScript libraries like React

React is used on the frontend, it’ll typically be used in conjunction with some sort of backend technology which would be responsible for fetching, storing & updating data.

In simple terms, React makes it easy to create smooth, dynamic applications using JavaScript.

Imagine you want to build a single-page application (SPA) using native JavaScript. That’s perfectly possible, and theoretically fine. However, there are a lot of things to consider and optimize. You’d have to manually handle all updates within the user interface, keeping everything consistent and keeping your data synchronised for the user!

As your app grows, this would inevitably become problematic and time-consuming to maintain.

Using a professional, scalable out-of-the-box solution like React (or Vue, or any number of other candidates) is the logical solution to this problem.

2. Learn server-side scripting with Node

Typically, JavaScript is perceived to be a “frontend” language primarily. However, these days, this is not really the case.

Node is a fantastic server-side language.

The good news here is that you can apply your existing JavaScript knowledge directly; you don’t need to learn a brand new language from the ground up.

If you’re looking to become a full-stack web developer, coupling Node with React is a classic combination that is probably fairly appealing to you at this point. Both are industry-standard, and both leverage JavaScript.

Of course, if you’re deciding what to learn after JavaScript – there’s no particular need to focus on the frontend aspect first. It may feel more natural to do this, but there’s (strictly speaking) nothing wrong with jumping straight to Node at this point, either!

Can I learn a different server-side language instead?


Of course. If you have your own particular reason(s) to use a different server-side language, such as PHP, for instance – then feel free to pick up that language up instead.

However, you should be aware that you’ll need to dedicate additional time to learning PHP. Your JavaScript skills will have limited value in this regard, as you’ll need to familiarize yourself with the new syntax, various new concepts, new features and so on.

The benefit of using Node here is that your JavaScript skillset can be leveraged to the fullest extent from the get-go. With a separate (non-JavaScript) based technology, that’s not necessarily the case.

3. Familiarize yourself with a database technology like MongoDB

With server-side technologies such as Node, you’ll typically want to hook up some sort of persistence layer.

By that, I mean you’ll want to be able to store data in a database, and interact with this data as and when required via your frontend application. This is a fairly typical requirement among web apps in general, it’s fair to assume that most apps would have some sort of persistence layer in some form.

This is where a tool like MongoDB would come in.


MongoDB is what is known as a NoSQL database. This means it’s fairly different to your traditional SQL-based database, such as MySQL or PostgreSQL.

I won’t go into the pros and cons of NoSQL vs SQL in this article, however, you should know that (generally speaking) MySQL is more structured, whereas NoSQL tends to be less rigid and more flexible.

I’d recommend this particular overview on the MongoDB website: NoSQL vs SQL to inform your decision with regards to which type of database you’d like to look at first.

It could be argued that a “typical” combination (as of the time of writing) would be Node + MongoDB, but it’s really down to personal preference and use-case.

There’s no particular reason why you can’t pair a Postgres database with Node, too, for example.

4. Acquaint yourself with version control

Version control (or source control) is basically the practice of managing and tracking changes and updates to your software (or project).

Git (and GitHub) would be one of the prime examples of version control software.

Whether you’re wanting to work in industry, amongst a team of other developers, or whether you’re looking to work exclusively on your own projects — you’ll definitely want to familiarize yourself with the basics of version control.

When asking what to learn after JavaScript, version control is perhaps not the most obvious candidate. But I’d argue you’ll definitely want to pick up this knowledge at some point, so why not sooner rather than later?

How does version control actually work?

In terms of a brief overview, here’s how version control works in principle:

  • You create a repository to store your project
  • You push your code to this repository, the code now exists remotely outside of your machine
  • During the push, you’ll supply a message like “Added the about page”
  • You make another change to the project, and push again

So you contribute changes, or commits, to your own remote repository. This effectively creates a backup of your work in a remote location, but you’re also getting a snapshot of the codebase every time you push updates.

As you may expect, you’ll have a full history which details all updates and changes that have been made to your project of it’s lifetime.

Working with others

Alongside this, another key aspect is the ability to share your project with other developers. This would work something like as follows:

  • You invite your buddy to your repository, he can now access your code and pull it down to his machine
  • He can propose updates, now, too
  • You can approve these updates, and merge them to your project

You can see via these basic principles how it becomes easy to share and collaborate with other developers. Each of you contributing to the same codebase seamlessly and in an organized manner.

Version control in general is extremely powerful, and this simple overview is barely scratching the surface. It’s well worth seeking out the many resources available on this topic, such as this great introduction to Git.

5. Start to learn about unit testing

One of the hallmarks of an experienced and capable developer is the ability to write testable, maintainable code.

By testable code, we mean code that is clean, easy to reason about and can be tested in a (somewhat) modular fashion. Ideally, you should be writing unit tests for both your frontend (React) and backend (Node) code!

For testing React code, I’d recommend a tool called jest. Moreover, there’s a great overview in the official docs over here: React Testing Overview.

Similarly, you can also use jest to test Node code. Remember, it’s all JavaScript!

The benefits of writing tests for your JavaScript code

When starting out as a developer, at first you may feel that manually testing your code is all you’ll need. This is simply not the case, this will become more apparent the more experienced you become.

It’s simply much more effective and efficient to also write unit tests covering the main functionalities of your software.

Unit tests provide peace of mind when adding new changes, as they provide a quick mechanism to easily verify that something hasn’t inadvertently been broken at some point along the way.

The tests also promote better coding practices in general, as you’ll need to more carefully consider how to lay out and structure your code. As stated, the code should be somewhat modular and thus easier to separate out and break apart.

If your code is hard to write unit tests for, it may well be the case that it’s poorly written or not very well organized to begin with.

Enforcing unit tests can put a stop to unorganized, unclear code and make your app much more robust in the process.

6. Get better at debugging your JavaScript

There’s a lot more to debugging that dropping the occasional console.log in your code!

For instance, you can take a look at the React Developer Tools.

This extension allows you to more easily identify the components (and their children) that have been rendered on the page.

Aside from React, you’ll find a lot of similar goodies to help you out with native JavaScript.

Often times, you don’t need to look any further than the in-built browser dev tools. If you’re unfamiliar, you’ll perhaps be surprised how powerful these dev tools can be and how many (useful) features they actually feature.

When deciding what to learn after JavaScript, it’s arguable that this point should come much sooner. There’s no set order to this stuff, really — the stronger your debugging skills become, the better time you’ll have with efficiently solving problems that would otherwise become blockers!

It’s well worth dedicating the time to learning these dev tools inside and out, as this will play dividends in the future.

7. Learn TypeScript

TypeScript is arguably the next logical step any JavaScript developer should be looking to undertake.

If you’ve only worked with JavaScript so far, you may not understand the power of strongly-typed programming languages.

TypeScript bridges this gap — it essentially provides strongly-typed facilities to JavaScript, which is loosely-typed by default.

A quick example of how TypeScript works

As a brief summary, here’s one example of this.

In JavaScript, you don’t need to define the type of a variable, like so:

const name = "Thomas"

But in TypeScript, you must define the type of this variable. This ultimately leads to much more robust and less error-prone code:

const name: string = "Thomas"

As a trivial example, enforcing types for your variables via TypeScript would prevent this kind of problem:

const firstNumber = 20
const secondNumber = "22"

console.log(firstNumber + secondNumber) // "2022"

We’re adding a number to a string, perhaps unknowingly/unwillingly, which can lead to unpredictable results.

We can’t make this same error with TypeScript, as firstNumber and secondNumber would each be initialized as numbers to begin with.

There are many, many benefits to TypeScript, it’s well worth acquainting yourself with it. It’ll ultimately make your applications more professional and less flaky by ironing out some of the issues and quirks inherent in native JavaScript.

Think about branching out…

I believe we’ve covered a lot of the main options already with regards to what to learn after JavaScript.

There are, however, a few other distinct paths that may be appealing or desirable to you at this point. Paths that can still effectively leverage the skills you’ve been building up to this point.

Let’s take a look at those!

8. Look into app development with React Native

It’s feasible to develop both iOS and Android apps using JavaScript alone!

React Native is used to construct iOS and Android apps from a single JavaScript codebase, meaning you can effectively “write once” — yet produce mobile applications that target multiple operating systems!

For JavaScript developers, this is fantastic. The alternative route would likely mean learning some other language and ecosystem (for example, you’d likely want to learn Java to build native Android applications).

Not only that, you’d need to learn the iOS equivalent in this case, provided you want both an iOS and Android version of your new application.

React Native solves this problem seamlessly, whilst still allowing you to lean on your existing JavaScript knowledge and experience to the fullest extent.

You could also consider Flutter

It’s worth noting that React Native is not the only tool that allows you to “white once” in this manner.

You can use other tools, such as Flutter, to the same end.

However, it’s worth bearing in mind that Flutter doesn’t use JavaScript – and that’s what we’re focussing on specifically in this article.

9. Explore serverless technologies

Last but not least, you can leverage your JavaScript skills in the serverless world, also.

Serverless programming is a break from the traditional approach — you’ll not need to manage servers or manually handle any of that infrastructure yourself.

One popular provider in this domain is Amazon Web Services (or AWS), it’s well worth acquainting yourself with what they have to offer in terms of serverless facilities and features.

Enter Node, again…

You can use many different languages in your serverless applications, but most notably for the purposes of this article — you can use Node.

This means that the transition into the serverless world can be eased somewhat via our old friend JavaScript.

In summary

I hope this article has been useful and somewhat of an enjoyable read!

As you can see, there are many options to consider when you’re starting to think about what to learn after JavaScript. Frontend, backend, “other” skills like the use of version control and unit testing — there’s a plethora of things to consider.

I hope the list above has shed some light on the various avenues available to you.

Be sure to check out the JavaScript category for more articles like this one!

Thanks for reading!

Have any questions? Ping me over at @justacodingblog
← Back to blog