The Most Popular Node.js Frameworks in 2023

The Most Popular Node.js Frameworks

As the demand for robust and scalable web applications continues to increase, Node.js remains a popular choice among developers. Node.js is a powerful open-source JavaScript runtime environment that allows developers to build fast and efficient applications. And with so many Node.js frameworks available, it can be challenging to choose the right one for your project.

To gain a better understanding of the current state of the Node.js ecosystem, I’ve put together the data from numerous surveys (State of JavaScript, StackOverflow), and I have analyzed the number of GitHub stars that a specific Node.js framework has gained day over day for the last 12 months. I’m also a Node.js enjoyer myself (I’ve written a 10,000-word Next.js tutorial for beginners), so I’m fairly up-to-date with the latest trends!

This guide is now in its second year of running! I’ve taken the time to rework it completely. I’ve added new featured images, I’ve redone descriptions, and I’ve also added a table that can be used to jump to the specific framework section.

Let’s start by taking a look at the overall rankings.

Framework Description Released Growth
Next.js The React Framework 2016 +53.3/day
tRPC Move Fast and Break Nothing. End-to-end typesafe APIs made easy. 2020 +51.5/day
Nest A progressive Node.js framework for building efficient, scalable, and enterprise-grade server-side applications on top of TypeScript & JavaScript. 2017 +26.5/day
Remix Build Better Websites. Create modern, resilient user experiences with web fundamentals. 2020 +24.3/day
Strapi Strapi is the leading open-source headless CMS. It’s 100% JavaScript, fully customizable and developer-first. 2015 +23.7/day
SvelteKit web development, streamlined 2020 +17.6/day
Directus Directus is an instant REST+GraphQL API and intuitive no-code data collaboration app for any SQL database. 2012 +17.1/day
Redwood The App Framework for Startups 2019 +12.7/day
Nuxt Nuxt is an intuitive and extendable way to create type-safe, performant and production-grade full-stack web apps and websites with Vue 3. 2016 +12.4/day
Fastify Fast and low overhead web framework, for Node.js 2016 +11.3/day
Express Fast, unopinionated, minimalist web framework for node. 2009 +10.8/day
Keystone The most powerful headless CMS for Node.js — built with GraphQL and React 2018 +4.9/day

It comes as no surprise that Next.js continues to dominate the Node.js landscape, and it doesn’t look like Vercel has any plans to stop either, as they released some major new features during their last conference; more on that later. The biggest change for the last year has been the rapid rise of tRPC, a framework for building typesafe APIs for Node.js applications. It pairs well with create-t3-app (Next, tRPC, Tailwind boilerplate), which also shot up in popularity.

Remix has also kept growing and was acquired by Shopify in late 2022. Outside of this, there hasn’t been a lot of fluctuation in general rankings. There has, however, been a slight shift in the types of full-stack/back-end frameworks available.

Most notably, both Fresh (a Deno framework) and Astro (SSG/SSR for content websites) got +9.5k and +15.1k stars on GitHub (in the last 12 months), respectively.

Last year, this segment highlighted the rise of meta-frameworks and the importance of SSR. This year, we can comfortably say that one of the most significant trends has been the rise and adaptation of APIs. More and more developers are getting comfortable with committing to one framework and then using external APIs/GraphQL to scale their operations.

My own take on it is that in 2023, you should focus on things like GraphQL dominance, serverless architecture, IoT applications, real-time apps, and microservices demand. Also, pretty much all the major FAANG companies are now building some kind of an AI model (Google, Facebook, OpenAI 🫠), so there are going to be a lot of opportunities to work with APIs and build on top of these models.

If you want to try any of these frameworks in a real-time environment, check out my article on hosting platforms for developers. Each platform has a free plan, and almost all of them let you import a GitHub repo and host it directly.

1. Next.js


Next.js is used for building server-side rendered (SSR) and statically generated React applications. It is developed by Vercel (formerly Zeit) and provides a set of features and conventions that make it easy to build complex web applications with React.

Next.js has been comfortably the most popular Node.js framework this year, and with how things are shaping up, I believe it will retain that spot next year, too. Just recently, the Next.js Conf concluded, and the two major things announced were Next.js 13 and Turbopack. If you’d like to catch up, you can read the official blog post here, or watch an hour-long keynote here.

Next.js is a React framework that provides developers with an easy-to-use solution for building web applications and websites. It is known for its flexibility, speed, and SEO-friendliness. Next.js takes care of the tooling and configuration needed for React and provides additional structure, features, and optimizations for your application.

It is ideal for developers who want to build high-performing React applications without spending too much time configuring tools and solutions. Next.js offers various benefits, such as pre-rendering, built-in routing, automatic code splitting, image optimization, CSS support, and a growing community of developers.

As a Next user, I can honestly say it’s one of the best development experiences you can have. You also don’t need to commit to using the framework for production websites/apps either.

You can export all your projects as static files and forget about the Node.js aspect altogether. This is great because it lets you tap inside the entire Next/React ecosystem and build modern sites without being tied to the back-end part.

To summarize, Next.js is a framework that extends React’s capabilities and simplifies the development process by providing developers with pre-built tools and configurations that enhance performance, speed, and scalability.

2. tRPC


As TypeScript becomes more widely adopted, developers are looking for frameworks and libraries that provide strong typing for their APIs. This is where tRPC can come in, as it provides a simple and intuitive way to define RPC APIs with TypeScript.

tRPC is framework for building RPC (Remote Procedure Call) APIs with TypeScript. The goal of tRPC is to provide a simple, type-safe way to define and use RPC APIs, focusing on developer productivity and ease of use.

One of the best things about tRPC is that it provides fully type-safe APIs without the need for code generation or schemas. This means that you can maintain type safety between your frontend and backend without having to write a lot of extra code.

With tRPC, you get all the features you need for building APIs, like authentication and request validation. And if you’re using popular front-end frameworks like React or Next.js – tRPC is compatible with those too!

One thing to keep in mind is that tRPC is still a relatively new project, so it might not work with all libraries and frameworks just yet. But the tRPC community is growing and actively working on adding support for more popular frameworks.

3. Nest


NestJS has quietly managed to attract significant approval from the back-end community. One of the main philosophies behind Nest is that while frameworks like React accelerate front-end development, many such frameworks struggle to solve the application architecture issue. Nest solves this through an architecture-first approach.

Which is specific to the back-end, of course.

Nest is based on three core components (inspired by Angular) – Controllers, Providers, and Modules. The use of Modules is how Nest tries to solve the problem of complex application hierarchy. Each component can be categorized in a separate module, within which you configure its own controllers, dependencies, and specific providers.

The main goal of Nest.js is to provide a structure for your application by using best practices from both object-oriented programming and functional programming. It does this by providing a modular architecture that allows you to organize your code into small, reusable modules easily.

One of the key benefits of Nest.js is that it is highly customizable and extensible. This means you can easily add new functionality and plugins to your application without modifying the core framework.

4. Remix


Remix is a web framework that makes it easy to build server-rendered applications. It’s a combination of a few different things: a compiler, a server-side HTTP handler, a server framework, and a browser framework.

  • A compiler – Remix starts with a compiler that generates a server HTTP handler and a browser build. The browser build includes code splitting, fingerprinted asset imports, and other features needed to run the application in the browser.
  • A server-side HTTP handler – This is created using esbuild and includes all the routes and modules needed to render the application on the server and handle server-side requests for resources.
  • A server framework – Remix’s server framework is designed to be flexible and can run on any JavaScript server. It can also be run on non-Node.js environments like Cloudflare Workers and Deno Deploy.
  • A browser framework – Remix’s browser framework “hydrates” the page with the browser build’s JavaScript modules and can fetch data for the next page and update the UI without making a round trip to the server for the entire document and all of the assets.

Remix is built on the Web Fetch API instead of Node.js, which allows it to work seamlessly with other server-side frameworks. Additionally, Remix is designed to be UI-focused, and each route module takes on both the view and controller responsibilities. Routes can handle an entire URL or just a segment of the URL, making it easy to build complex applications with minimal boilerplate code.

Last but not least, Remix provides client-side APIs to create rich user experiences without changing the fundamental model of HTML and browsers. It offers a simple and scalable way to build web applications that are fast, accessible, and easy to maintain.

5. Strapi


Strapi is a Node.js-based headless Content Management System (CMS) and API server that allows you to easily create and manage content APIs and applications.

In simpler terms, Strapi provides you with a pre-built backend that you can use to manage your content and data. This backend includes features such as user authentication, content types and fields, data validation, and more.

By using Strapi, you can quickly set up a RESTful API for your content that can be used by any front-end framework or technology, such as React or Vue.js. This allows you to focus on building the frontend of your application, without worrying about building and managing a complex backend.

Additionally, Strapi is highly customizable, allowing you to tailor it to your specific needs. It also includes a built-in administration panel that makes it easy to manage your content and data.

Overall, Strapi is a great choice for anyone looking to build a content-focused application, without the need to spend a lot of time building and managing a complex backend. It’s easy to use, highly customizable, and can help you get your application up and running quickly.

6. SvelteKit


SvelteKit is a web application framework that is built on top of the Svelte JavaScript framework. It is designed to help developers build fast and efficient web applications using modern web technologies such as Node.js, TypeScript, and GraphQL.

At a high level, SvelteKit is designed to provide a simple and streamlined way to build web applications by reducing boilerplate code and providing a set of common features out of the box. These features include things like server-side rendering, client-side routing, and code splitting, all of which contribute to the overall development experience.

One of the unique features of SvelteKit is that it supports multiple output formats, such as server-rendered HTML, static site generation, and single-page applications, which makes it flexible enough to handle a wide range of use cases.

Additionally, SvelteKit offers a powerful data-fetching API that makes it easy to fetch data from APIs and databases, and then render it on the server or client-side. This API is highly customizable and allows for advanced data-fetching strategies such as caching and pagination.

7. Directus


Directus is a headless CMS and API toolkit built on Node.js. It is designed to provide an easy and flexible way for developers to build custom content management solutions and APIs.

At its core, Directus separates the content management and delivery layers of a website or application, allowing you to build custom front-ends and integrate with any backend or database system. Directus provides an intuitive user interface for managing content, including data entry, editing, and versioning.

Also, Directus is built on a modular architecture. It comes with a powerful set of built-in features, such as user authentication and authorization, role-based access control, and custom field types. Additionally, Directus can be easily integrated with other Node.js modules and frameworks to extend its functionality.

If you’re new to Node.js, Directus may take some time to learn, but its robust documentation and helpful community make it a great choice for getting started with building custom content management solutions.

8. Redwood


Redwood is a modern web application framework for building full-stack, serverless JAMstack applications with React and GraphQL. It’s built on top of popular technologies such as Node.js, Prisma, Storybook, and Jest.

Redwood also includes a number of other features that make it easy to build web applications, such as a command-line interface (CLI) that helps you generate boilerplate code, a router for handling URLs and routing requests to the appropriate page, and a database layer that lets you store and retrieve data from a database.

Redwood is particularly well-suited for building real-time, data-driven web applications. It uses GraphQL to manage data and Prisma to interact with databases, which makes it easy to handle complex data relationships and queries. In fact, Redwood provides a lot of features out of the box that make it easy to build scalable and maintainable web applications, including:

  • A robust CLI that makes it easy to generate new components, pages, and services.
  • A well-organized file structure that promotes clean architecture and separation of concerns.
  • A powerful GraphQL API layer that allows you to declaratively define your data schema and resolvers, and generates the necessary client-side code for querying and mutating your data.
  • A comprehensive testing framework that helps you write high-quality tests for your application.
  • A plugin system that allows you to easily extend Redwood’s functionality with additional packages.

When it comes down to it, Redwood is a great choice for anyone who wants to build modern web applications with Node.js, React, and GraphQL. It’s easy to learn and use and provides a lot of powerful features that will help you build your app quickly and efficiently.

9. Nuxt


As I mentioned last year – Nuxt was working on migrating from v2 to v3, and that migration was finalized in November 2022. The new v3 version includes a rewrite that’s based on Vite, Vue3, and Nitro. And since Vue 2 is reaching the end of life soon, Nuxt 3 will become the default version.

Nuxt.js is a framework for building server-side rendered (SSR) Vue.js applications. The main purpose of Nuxt is to simplify the development process by providing a set of conventions and tools for building web applications. With Nuxt, you can create a web application with minimal setup and configuration, as many common tasks are handled for you automatically.

One of the key features of Nuxt is its ability to generate static websites that can be hosted on a server or served directly from a CDN. This can provide significant performance benefits, as static sites are typically faster to load and require less server resources than dynamic sites.

Nuxt also includes a number of other features that can be useful for building web applications, such as server-side rendering, middleware support, and built-in support for SEO optimization.

10. Fastify


Fastify was created with the goal of providing a lightweight and highly performant framework for building web applications, APIs, and microservices.

One of the main benefits of Fastify is its speed. It is built with a focus on performance, which means it can handle a large number of requests per second with minimal overhead. This can be especially important for applications that need to handle a high traffic volume.

FrameworkRequests per second
Please note that the table displays results from a synthetic “hello world” benchmark designed to assess framework overhead. It’s important to keep in mind that the actual overhead of a framework on your application can vary depending on your specific use case, and it’s recommended to conduct benchmarking if performance is a critical factor for your project.

Some of the key features of Fastify include the following:

  • Low overhead – Fastify is designed to be extremely lightweight and performant, with a low memory footprint and high throughput. This makes it a great choice for building scalable applications and APIs that can handle a high volume of traffic.
  • Async/await support – Fastify fully supports async/await, which makes it easy to write asynchronous code that is easy to read and maintain. This is particularly useful when building web applications and APIs that need to handle many concurrent requests.
  • Plugins – Fastify has a powerful plugin system that makes adding new features and functionality to your application easy. There are many third-party plugins available for Fastify that can help you quickly add features like authentication, validation, and caching.
  • Middleware support – Fastify supports middleware, which allows you to add functionality to your application’s request/response processing pipeline. This makes it easy to add features like logging, error handling, and request validation.

Overall, Fastify is a great choice for developers who value speed, efficiency, and scalability, and want a flexible and customizable framework for building server-side applications in JavaScript.

11. Express


Despite declining popularity, Express remains a powerful and widely used web application framework. It is still maintained by a dedicated team of developers and has a large community of users who continue to use it for building web applications. Express did extremely well in the State of JS survey (20k people voted for Express from 23k total respondents), and 23.19% of 45k professional devs voted for it in the StackOverflow survey.

Express is a minimal and flexible framework that provides a range of features and functions to simplify the process of building web apps.

One of the key advantages of Express is its routing system. Express provides a simple and powerful routing system that maps requests to specific functions or handlers that will handle the request.

This makes it easy to create custom endpoints for different parts of a web application.

const express = require('express');
const app = express();

// Route handler for the home page
app.get('/', (req, res) => {
  res.send('Hello World!');

// Route handler for the about page
app.get('/about', (req, res) => {
  res.send('About page');

// Route handler for a dynamic URL
app.get('/users/:id', (req, res) => {
  const userId =;
  res.send(`User ID: ${userId}`);

// Start the server
app.listen(3000, () => {
  console.log('Server listening on port 3000');

Another advantage of Express is its middleware system, which allows you to add functionality to your apps in a modular way. Middleware functions are functions that are executed before the request reaches the route handler. This allows developers to avoid cluttering the main application code with repetitive logic.

Despite the emergence of new Node.js frameworks, Express remains a popular choice, particularly for simple back-end needs. Express is also (to this day) the primary framework that MDN uses for its Node.js tutorials, so if you’re a complete beginner – it’s super quick to learn.

12. Keystone


Keystone is a framework that simplifies the process of building backends for web applications. With Keystone, you can create custom backends without the need for boilerplate code or bootstrapping. This framework offers powerful features such as a GraphQL API, automated CRUD, flexible access control, database migrations, and more.

Keystone also provides an intuitive CLI and a flexible editing environment that can be customized to fit the needs of different projects. Additionally, Keystone is built using tools and concepts that developers are already familiar with, such as TypeScript, making it easy to integrate into existing workflows.

In terms of applications, Keystone can be used for a wide range of projects, including apps, websites, and eCommerce solutions. It is a programmable backend that can be relied upon for web and native apps of all sizes. It can be controlled exclusively from the front end or integrated with Keystone’s intuitive and customizable CMS when needed.


I want to conclude this post by saying that I did not forget about Meteor, Koa, Sails, Hapi, egg, and other mature Node.js frameworks. They’ve been less popular when it comes to the metrics I used to put this entire roundup together.

Previous Post
Build Tools for Front-end Developers

The Most Popular Build Tools for Front-end Developers in 2023

Next Post
The Most Popular Deno Frameworks in 2023

Deno Frameworks: Building Faster, More Secure Applications

Related Posts