[2023 edition] Comparison summary of various popular Node.js frameworks


More and more developers are using Node.js today, and the vast majority of developers are looking to use the Node.js framework to enable them to develop more applications.

However, the Node.js framework has seen so much development since its introduction in the tech community in 2009 that more and more engineers are wondering which framework to use.

The Node.js framework is roughly divided into 3 parts, and you have to decide which one to use depending on the project.

  • MVC framework It adopts a design pattern that divides the application logic into three parts: Model (M), View (V), and Controller (C). The advantage of this is that the development responsibilities can be separated, allowing designers to focus on design and programmers to create functionality.

  • Full stack framework We have all the components to create an application. Accompanying the idea of ​​MVC framework, it provides features such as libraries, template engines, etc.

  • REST API framework A framework for creating REST APIs. Unlike MVC frameworks and full-stack frameworks, you can’t create an application with this alone. You will mainly focus on backend functions.

With that in mind, here are the frameworks to choose from when using Node.js in 2023.

framework list

| name | Github | Star | | ————————————————- ————————————————– ————- | – | —– | —————— | | Express.js | https://github.com/expressjs/express | 52.0K | 1st place | | Nest.js | https://github.com/nestjs/nest | 34.7K | 2nd place | | Koa.js | https://github.com/koajs/koa | 30.8K | 3rd place | | Meteor.js | https://github.com/meteor/meteor | 42.3K | 4th place | | fastify | https://github.com/fastify/fastify | 17K | 5th place | | Sales.js | https://github.com/balderdashy/sails | 21.8K | 6th place | | LoopBack.js | https://github.com/strongloop/loopback | 13.3K | 7th place | | AdonisJs | https://github.com/adonisjs/core | 9.6K | 8th place | | Total.js | https://github.com/totaljs/framework | 4.1K | 9th place | | Derby.js | https:/ /github.com/derbyjs/derby | 4.6K | #10 |

Node.js framework list table


Since its release in 2010, Express.js continues to be developed under the MIT license. It is the de facto standard for Node.js.

It provides the functionality necessary to develop web applications on the server side.

It adopts MVC architecture, and you can create applications using only this framework. In addition to the MVC architecture, it also has aspects as a REST API framework and can be used separately depending on the project. It is very versatile and extensible, with many packages being developed. You can also develop more complex applications by combining them.


  1. Simple and lightweight It has only the minimum necessary functions. So it works very smoothly. The cost of learning is also very low.
  2. MAIN FUNCTIONS REQUIRED FOR WEB APPLICATION DEVELOPMENT It provides the main features and provides basic functionality such as routing, middleware, and template engine, providing a basic framework for developing web applications.
  3. Abundant packages A framework that has been out for many years. Therefore, there are plenty of modules that support development. By combining them, you can develop more complex applications.
  4. Abundant template engine There are multiple template engines as well, supporting Pug, EJS, Mustache and more.
  5. Community Support Lots of tutorials, documentation, and libraries available for learning resources
  6. High scalability It can meet the development requirements of various applications.


  1. It is doubtful whether functions will be added or modified in the future The development team of Express.js is focused on developing its successor, koa.js. Future updates may be affected
  2. Not suitable for overly complex API development In order to develop complex applications, it is necessary to combine libraries and frameworks by yourself, so the learning cost may be high.


Install the executable.

npm install -g express-generator

** App creation **

express /tmp/foo && cd /tmp/foo

Install dependencies

npm install

Start Server

npm start

Sample code

var express = require('express')
var app = express()

app. get('/', function (req, res) {
  res.send('hello world')


Author Rating

The advantages of using Express.js are that it is easy to set up, has a low learning cost, and is highly compatible with a wide variety of packages. Also, since it can be incorporated into the Node.js ecosystem, it is highly evaluated for its flexibility in development.

The disadvantage is that the learning cost may be high because you need to combine libraries and frameworks yourself to develop complex applications. Also, in order to implement your own middleware, you need to implement it yourself, so the development cost may increase.

On top of that, Express.js is often superseded by newer frameworks like Nest.js and fastify these days, so keep an eye out for future updates and support.

Overall, Node.js is a good choice for web application development due to its simplicity and light weight, but for complex application development and scaling, choosing the right architecture is a must. , should be combined with appropriate middleware.

However, it has a very low learning cost for simple API development. It is the framework No1 that I would personally recommend to beginners. If you want to learn more about Express.js, see Beginner’s introduction to Express.js.


A Node.js framework for building efficient and scalable Node.js applications.


  1. Can use TypeScript Nest.js is built with TypeScript. This allows for strongly typed implementations.
  2. Reduction of development time by dedicated CLI There is also a command line called Nest CLI. By using this, you can easily build Nest.js applications.
  3. You can use the architecture of Express.js as it is Nest.js also makes use of Express.js, so you can take advantage of the architecture available in Express and build maintainable applications.


  1. High learning curve: NestJS recommends a specific architecture and design principles for building Node.js applications. This can create a high learning curve for developers using NestJS for the first time. Especially if you are familiar with Express.js and other frameworks, it may take time and effort to adapt to the differences.
  2. Slower development: NestJS is designed for building efficient and scalable applications, but it can also slow down development for some developers. Additional layers of abstraction and features provided by frameworks can improve performance and robustness at the expense of flexibility that the developer has direct control over. Therefore, depending on project requirements, a simpler approach may be preferable.
  3. Maturity of the ecosystem: NestJS is a relatively new framework and its ecosystem may not yet be fully developed compared to other more mature Node.js frameworks. Some libraries and plugins may have limited availability compared to other frameworks. Therefore, it can be difficult to find ecosystem support that meets your specific needs and requirements.


npm i -g @nestjs/cli
nest new project

Sample code

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);

Author Rating

NestJS’ strength lies in its code maintainability. It can be written in the same way as Angular, and it is written in TypeScript, making it easy to organize architectural patterns.

Large projects allow you to keep your functionality clean and modular, resulting in scalable and maintainable application development.

If you want to learn more about NestJS, please refer to “Introduction to NestJS for beginners”.


Developed by the Express.js team, it is a lightweight framework that omits some of the Express.js features.

As a successor, it uses the MVC architecture pattern. So you can create one application with this one framework.

As with Express.js, you have to implement middleware yourself. You can now write your processing using ES6 generators, making it easier to handle asynchronous processing.

Koa.js has its own scripts and methods for working with different browsers. Also, since the method of description is similar to Express.js, the learning cost is slightly lower.


  1. Simple and lightweight Express.js is a minimalist application, Koa.js goes above and beyond. Middleware, routing, etc. are not provided, you have to build it yourself. This sounds like a disadvantage, but unlike Express.js, you don’t have to learn core modules and middleware from scratch, and you can easily add what you need, so it’s an advantage in long-term development. .
  2. Generator Koa.js allows you to write asynchronous operations using ES6 generators. This makes the code easier to read and easier to handle.
  3. Community support Koa.js is popular within the Node.js community and has many libraries and plugins.
  4. High scalability It can meet the development requirements of various applications.


  1. Potentially longer development time For better or worse, it’s a minimalist framework. It takes time to select and test modules to use.
  2. Self-implementation of middleware You are required to implement middleware processing yourself. This can take time and effort.
  3. Reduced support functions Fewer out-of-the-box features compared to Express.js, which can slow down your productivity.
  4. Enforcing ES6 Since it uses ES6 generators, it cannot be used in environments where generators are not supported.


npm i koa
node project.js

Sample code

const Koa = require('koa');
const app = new Koa();

app. use(async ctx => {
  ctx.body = 'Hello World';


Author Rating

Developed by the developers of Express.js, it is a framework with great expectations for the future. It has improved performance compared to Express.js and works very fast.

Since it uses the ES6 generator, it cannot be used in an environment that does not support the generator, but as of 2023, it is rare to have an environment that does not use it, so it may not matter too much.

Overall, Koa.js is a lightweight web framework that requires you to implement middleware yourself, so it is expensive to learn and has the advantage of being able to write clean code. It can be said that it is a disadvantage that it cannot be used in an environment where it is not


A full stack open source framework that has been in development for over 10 years.

This framework has a simplified platform for the entire app hierarchy and can be developed entirely in JavaScript. This allows you to develop this framework on the server side as well as the client side in a more efficient way.

We also have a dedicated cloud to support Meteor app development.


  1. Easy development Meteor.js, like Node.js, uses JavaScript. Therefore, you can develop web applications using JavaScript. Meteor.js also allows you to create and deploy applications using simple commands.
  2. Mature and stable An open source framework developed over 10 years. Disruptive updates are unlikely.
  3. Full-stack framework All work from development to release can be written in JS Therefore, if you introduce Meteor.js, you will have all the environments necessary for development, so you can start developing right away.
  4. Real-time data synchronization Meteor.js uses the Distributed Data Protocol (DDP) to provide real-time data synchronization for both server and client. This makes it easy to create real-time web applications because the client is automatically updated when data on the server changes.
  5. Extensive library Meteor.js provides a rich library. Using these libraries can improve the functionality and performance of your application.
  6. Abundant Japanese documents Currently, there are many Japanese documents, so it is easy for beginners.


  1. Front-end restrictions Meteor.js discourages using more widely used frameworks such as React, Angular, and Vue for the front end. This is because Meteor.js relies on the built-in front-end framework Blaze.
  2. Developer brand Meteor.js is lesser known than more commonly used frameworks such as React and Angular and can require time and effort for developers to learn it.
  3. Lack of scalability Meteor.js is not well suited for large scale applications. This is because as your application scales, Meteor.js will run out of functionality. As your application grows, you will need to create custom functionality.
  4. Server-Side Limits Meteor.js only runs on specific servers, which can limit maintenance and expansion if it needs to run server-side.
  5. Architectural flaws Meteor.js is based on a single codebase that does not separate client and server application logic. This means that if your application continues to grow, your codebase can become complex and difficult to maintain.


curl https://install.meteor.com/ | sh
mkdir project
cd project
meteor create.
meteor run

Sample code

import { Template } from 'meteor/templating';
import { ReactiveVar } from 'meteor/reactive-var';

import './main.html';

Template.hello.onCreated(function helloOnCreated() {
  // counter starts at 0
  this.counter = new ReactiveVar(0);

  counter() {
    return Template.instance().counter.get();

  'click button'(event, instance) {
    // increment the counter when button is clicked
    instance.counter.set(instance.counter.get() + 1);

**Author Rating**

Meteor.js is a full-stack JavaScript framework for building web applications using JavaScript on both client and server. Many developers use it to create speedy and efficient web applications.

The biggest advantage of Meteor.js is speed of development. You can develop both client and server code at the same time, saving development time. It also has a Live Reload feature, which automatically reloads when you save code changes, facilitating application development.

Meteor.js has a rich community, so there are many packages and libraries to meet various needs. You can also build web, iOS, and Android applications with a single codebase.

The downside of Meteor.js, on the other hand, is its lack of flexibility. It is more difficult to customize than other frameworks, so for large applications it is recommended to use the more flexible framework.

Overall, Meteor.js is a great framework for easily building fast and efficient web applications, suitable for developing small and medium-sized applications.


The fastest performing Node.js framework.


  1. High speed It offers the fastest execution speed among node.js applications.
  2. Lightweight The functionality of the core library is kept to a minimum, and only the minimum necessary functions are provided. Therefore, it is lightweight, uses less memory, and is capable of high-speed processing.
  3. Scalability fastify can be easily extended with plugins. This allows you to add functionality as needed.
  4. TypeScript support fastify supports TypeScript, allowing you to develop applications written in TypeScript. Using TypeScript makes your application more maintainable and less prone to bugs.
  5. Extensive documentation Fastify has extensive documentation, so even beginners can easily learn how to use it. It’s also heavily supported by the community, and questions are often answered quickly.


  1. Few Japanese documents Since the official document is in English, it is not recommended for beginners because it has to be read and understood.
  2. Small number of developers Fastify is a relatively new framework, and the challenge is that the number of developers is still small. As such, community support may be lacking at times.
  3. There are plugin compatibility issues Fastify can be flexibly extended by using plugins, but there may be compatibility issues between plugins. Therefore, be careful when using multiple plugins in combination.
  4. Difficult fastify is optimized to achieve high speed processing, but on the other hand there are cases where detailed settings are required. For example, if you want to change how query parameters are parsed, you’ll need to implement your own parser.


npm install fastify-cli --global
fastify generate project
cd project
npm install
npm run dev

Sample code

// Require the framework and instantiate it
const fastify = require('fastify')({ logger: true })
// Declare a route
fastify.get('/', async (request, reply) => {
  return { hello: 'world' }
// Run the server!
const start = async () => {
  try {
    await fastify. listen(3000)
  } catch (err) {

Author Rating

Very fast, that’s all. Considering the maintainability of the code, I think it is a little difficult, but it can be improved in any way depending on the ingenuity of the developer.

It’s a very powerful option if your product requires fast response times.

If you want to learn more about fastify, please refer to “**Introduction to fastify from inexperienced **”.


Ruby-like Node.js framework. Used to develop your own enterprise-quality Node.js applications.

Sails.js consists of a data-driven API attached to a scalable service-oriented architecture.


  1. Ruby-like notation If you’ve used Ruby before, it’s easy to catch up.
  2. Very simple database access Waterline, an ORM, is installed as standard and database access is easy.
  3. Reduction of development time by dedicated CLI There is also a command line called Nest CLI. By using this, you can also create a very easy API.
  4. Developing high-level WebSocket applications Salis.js has mechanisms to facilitate WebSocket integration, making it a great candidate if you want to create an application using WebSockets.


  1. Lots of dependencies Sails.js uses many libraries such as Express.js, Socket.io, Waterline, etc. Each of these libraries has different versions and can conflict with each other.
  2. Poor performance Sails.js uses WebSockets by default, but WebSockets are better for long-lived connections and may experience delays on short-lived connections. Also, Sails.js has a relatively large memory footprint, which can lead to poor performance in resource-constrained environments.
  3. Lack of documentation Sails.js is well documented, but some features are lacking. Also, when new versions are released, the documentation may not keep up.
  4. ORM limitations Sails.js uses the Waterline ORM, which has limitations. For example, if you’re dealing with many-to-many relationships, you’ll have to create the intermediate table yourself.
  5. Few Developers Sails.js is a relatively new framework and the number of developers is still small. Therefore, it may be difficult to get an answer to your question.


npm install sails -g
sails new project
cd project
sails lift

Sample code

// api/controllers/HelloController.js

module. exports = {
  sayHello: function(req, res) {
    return res.send("Hello World!");

module.exports.routes = {
  "GET /hello": { action: "hello/sayHello" }
const sails = require("sails");

sails.lift({}, (error) => {
  if (error) {
    return process. exit(1);

  sails.log.info(`Server started at http://localhost:${sails.config.port}`);

Author Rating

Sails.js is a Node.js web application framework based on MVC architecture that can automatically generate APIs, making it easy to create RESTful API servers. It also makes routing and model creation easier, increasing developer productivity.

However, Sails.js is not suitable for complex application development. Also, some security features are disabled by default, so you need to be careful about security. Furthermore, I think that it is not suitable for customization because it is not flexible and has a low degree of freedom.


A framework for fast creation of REST APIs.


  1. Shorter development time with dedicated CLI Since the model is created on a command line basis, the coding work can be greatly reduced.
  2. Default built-in online document generation function Since Swagger, which generates online documentation for REST APIs, is built in as standard, you can share the created APIs as they are.
  3. Automatically generate REST API LoopBack.js has the ability to auto-generate a REST API from your data model. So you can easily implement CRUD operations.
  4. Easy to connect to various data sources LoopBack.js supports a wide variety of data sources, including multiple databases and APIs, making it easy to connect and access them.
  5. Flexible architecture With LoopBack.js, each element such as data source, routing, authentication/authorization, and custom code is independent, so a flexible architecture can be realized.
  6. Express.js-like syntax It’s easy to catch up if you’ve used Express.js before.
  7. Extensive documentation LoopBack.js has a rich official documentation, so the learning cost is relatively low and the development efficiency is improved.


  1. Expensive to learn LoopBack.js is feature rich and expensive to learn. In-depth knowledge is required, especially when implementing complex APIs and security features.
  2. The framework lacks flexibility LoopBack.js can lack the flexibility of a framework, as it must adhere to already defined basic functionality and design principles. When developing applications with a high degree of freedom, it may be necessary to implement custom functions.
  3. Plugin compatibility can be an issue LoopBack.js provides many plugins, but plugin compatibility can be an issue. Be careful when upgrading.
  4. Some functions are heavy LoopBack.js has heavyweight features such as remote methods and security features. This may affect performance when using some features.


npm install -g loopback-cli
lb app
npm start

Sample code

import {get} from '@loopback/rest';

export class HelloController {
  hello(): string {
    return 'Hello world!';

Author Rating

LoopBack.js is a full-stack web application framework that provides various functions such as connection to data sources, automatic generation of REST API, routing, authentication/authorization, etc. It may be a little difficult for beginners, but it is suitable for developing medium-sized or larger web applications because it has a lot of official documents and improves development efficiency.


It is a Node.js MVC framework for developing full-stack applications or APIs that are gaining popularity overseas.

It saves you the time of choosing multiple packages and lessens the burden on developers by taking advantage of the already bundled features that are so feature rich.

It also supports ORM and makes complex and cumbersome database operations easy.


  1. Laravel-like framework It can be developed in a Laravel-like writing style, which is a PHP framework. If you’ve used Laravel before, it’s easy to catch up.
  2. You can use various functions by default. It comes standard with routing, validation, and migration functionality. Just install Aonisjs without having to install other features.
  3. TypeScript enabled Recently updated to V5 after a long time. This update incorporates TypeScript, The framework core and all surrounding packages have been rewritten in TypeScript
  4. Fast processing speed In V4, the processing speed was one step short of fastify, but now it is almost the same as fastify.
  5. It is popular overseas Due to the recent V5, the number of overseas developers is increasing.
  6. Security Adonisjs provides security features to protect against security attacks such as XSS and CSRF.
  7. ORM support We provide a powerful ORM, Lucid ORM, which supports various databases such as SQL and NoSQL.
  8. Code generation tools Adonisjs has built-in code generation tools that allow developers to easily generate models, migrations, controllers, middleware, forms, and more.


  1. Few Japanese documents Currently, there is no official English document, so I have to read the English document.
  2. Not much excitement in Japan Since there are few Japanese articles when encountering problems, it seems that there is a quirk for Japanese people to use.
  3. Scalability limitations Adonisjs is based on an MVC architecture, so you develop applications that are tied to the internals of the framework. This can limit the scalability of your application.


npm i -g @adonisjs/cli
adonis new project
adonis serve --dev

Sample code

// Handle GET request
Route. get('posts', async ({ view }) => {
  return view.render('posts/index')

// Handle POST requests
Route.post('posts', async ({ request }) => {
  return request.body()

Author Rating High learning cost and complexity due to many functions. Also, be aware that framework updates are frequent and updates can break existing code.

Unfortunately, it’s not a framework that I would recommend to anyone.


The main features of Total.js are blazing fast performance, modularized architecture, multi-platform support, integrated autoloading, multi-language support, WebSockets and more.

The framework is based on the MVC pattern, making it easy to understand the structure of your application. It also provides many built-in features so you can develop web applications without writing your own code.

Additionally, it is compatible with a large number of database systems, such as Ember, MongoDb, etc.


  1. Tools optimized for mobile devices and CMS sites Optimized for developing web apps for mobile devices and creating CMS sites, speeding up development.
  2. MVC architecture Since the roles are divided, development with high maintainability can be performed.
  3. Highly extensible and asynchronous framework It can be extended and made public.
  4. Full support for RESTful routing mechanisms Supports Express-like routing.
  5. Full support for Web Sockets and media streaming Since functions are supported by default, there is no need to select or install modules.


  1. Small community and limited documentation: Total.js is a relatively new framework, and its community and number of developers may be limited compared to other more mature frameworks. As such, there may be a limited amount of resources and documentation for finding solutions and support. If you have a problem, you may not have the right support system to ask for help or it may take a long time to find a solution.

  2. Stability and reliability unknowns: As Total.js is a relatively new framework, its stability and reliability are unknowns compared to other mature frameworks. Bugs and security vulnerabilities may be found, and corresponding patches and updates may be delayed. Risks have to be considered in terms of stability and reliability compared to more established frameworks.

  3. Fewer plugin and module choices: Total.js’ ecosystem can be limited compared to other more mature frameworks. There may be limits on the number and quality of plugins and modules to accomplish certain tasks or functions. As such, you may need to create your own custom implementation to meet your specific needs.


npm install total.js
cd project
node index.js

Sample code

// Initializes Total.js framework 4

// Registers a route
ROUTE('GET /', function() {
// this === Controller
this.json({ message: 'Hello world' });

// Registers a WebSocket route
ROUTE('SOCKET/', function() {
  // this === controller

  this.on('open', function(client) {
    client. send({ message: 'Hello' });
  this.on('message', function(client, message) {

// Launches a web server in "debug" mode

Author Rating

Total.js is a fast and flexible web application framework, especially for prototyping. However, it should be kept in mind that it has a small developer community and may be difficult to gather information on due to its low profile compared to other frameworks.


A full-stack framework for Node.js that allows seamless data synchronization between server and client.


  1. Seamless data sync Derby.js automatically synchronizes data between browsers, servers and databases. This is because it employs a data synchronization engine called Racer.
  2. Easy to create multi-user applications Seamless data synchronization makes it easy to maintain consistency.
  3. Supports offline application development
  4. Express.js based It inherits the rich functionality of Express.js. This makes it relatively easy to learn for developers who have used Express.js.


  1. Limited documentation and small community: Derby.js is a relatively small framework, so official documentation and resources can be limited. Also, because the community is small, you may have limited resources to troubleshoot or seek support. When it comes to support for new features and updates, it can be difficult to find enough information.
  2. Uncertainty of maturity and stability: Derby.js is a relatively new framework, and there are uncertainties about its maturity and stability compared to other more established frameworks. Bugs and security vulnerabilities may be found, and corresponding patches and updates may be delayed. Stability and reliability require more detailed investigation when considering use in a production environment.
  3. Technology Stack Constraints: Derby.js employs a data synchronization engine called Racer, whose characteristics may impose limitations on certain technology stacks. This limitation can affect developers’ use of existing tools and libraries. Integration and interoperability with other frameworks and libraries should be considered.


npm install -g derby-cli
derby new <project name>
cd <project name>
node index.js

Sample code

const express = require('express');
const derby = require('derby');
const app = derby.createApp('hello', __filename);

app. get('/', function(page) {


const expressApp = express();

const port = process.env.PORT || 3000;
expressApp.listen(port, function() {
  console.log(`Server listening on port ${port}`);

Author Rating

It’s a relatively new framework and not used by many developers yet. As such, it has little community support and can be poorly documented. You may also encounter compatibility issues when migrating to derived projects.

Overall, Derby.js is a great framework for building real-time web applications, but it’s currently poorly documented and not recommended for beginners.


Each framework has advantages and disadvantages, and the optimum framework differs depending on the situation to be used. In addition, by preparing environment construction and Hello World sample code, even first-time users can easily try it. In the general review, I described the evaluation of each framework.

The choice of these frameworks should be made according to development objectives, requirements, skill sets, etc. Compare each framework and choose the best one for your project purpose.