TTB Tech Help

Practical tech help, security alerts and big tech news in plain English

Best Express.js Alternatives for Node.js in 2026

10 Best ExpressJS Alternatives

Express 5.1.0 replaced Express 4 as the default npm install express version on March 31, 2025, so if you’re asking whether to leave Express, start by upgrading it. If your app has outgrown Express, the strongest alternatives are Fastify for faster Node.js APIs, NestJS for large teams, Hono for edge and multi-runtime apps, and Elysia for Bun. This guide gives each one’s exact current version, Node.js requirement, cost and limits, and how much work the move takes.

Best defaultExpress 5
Faster Node APIsFastify
Big teamsNestJS
Edge and serverlessHono
Bun projectsElysia

Key takeaways

  • Express 5 handles async errors on its own and is the npm default, so upgrading is the cheapest fix.
  • Express 4’s earliest end-of-life target has passed. Plan to move off Express 4 now.
  • Fastify is the easiest move off Express. Its @fastify/express plugin keeps your old middleware running while you port routes.
  • Hono runs the same code on Cloudflare Workers, Bun, Deno and Node.js. Elysia is built for Bun first.
  • Fastify 5, NestJS 12 and Hono’s Node adapter v2 all need Node.js 20 or newer, and Node 20 reached end of life on April 30, 2026.

Contents

1. How these alternatives were chosen
2. Is Express still worth using in 2026?
3. Express alternatives compared at a glance
4. Fastify: the closest upgrade from Express
5. Hono: for edge, serverless and running anywhere
6. NestJS: structure for big teams
7. Koa: the Express team’s minimalist follow-up
8. Elysia: Bun-first and type-safe
9. Other options worth knowing: hapi, Restify, Encore, Feathers, h3
10. What about speed? Reading the benchmarks honestly
11. How to migrate off Express without a rewrite
12. Which one should you pick?
13. Looking for ExpressVPN alternatives instead?
14. FAQ
15. Next step

If you came here looking for ExpressVPN alternatives, skip to “Looking for ExpressVPN alternatives instead?” near the end. The rest of this page covers the Express.js web framework for Node.js.

How these alternatives were chosen

The six main picks were judged on maintenance, fit and migration cost, not on benchmark charts. Koa, hapi, Restify, Encore, Feathers and h3 also come up further down. Here are the criteria, roughly in order of weight:

  1. Active maintenance: a 2025 or 2026 release and a clear support policy.
  2. Fit for the job Express does: HTTP APIs and server apps on Node.js or a compatible runtime.
  3. Migration cost from Express: whether you can move route by route or need a rewrite.
  4. TypeScript and validation support: built-in options, not just bolt-ons.
  5. Ecosystem size: npm download volume and the range of plugins.

Raw speed counts for less here than in most roundups. “What about speed? Reading the benchmarks honestly” explains why.

Older lists often mixed in front-end libraries. Ember.js, Backbone.js, Vue.js, Knockout.js and Angular run in the browser and don’t replace Express. Meteor is a full-stack platform, not an HTTP framework. Sails.js is built on top of Express, so switching to it doesn’t take you off Express. Polka is a tiny Express-like router that has seen little recent activity, and DerbyJS is a full-stack MVC framework, not an HTTP layer, so neither made the main list.

Is Express still worth using in 2026?

Yes, for most projects. Express 5 fixed its biggest weakness, unhandled async errors. It’s still the most-installed Node.js web framework by a wide margin, and the OpenJS Foundation project now has a published support policy. Express 4 is a different story. If you’re still on it, you have upgrade work to do.

Developers on r/node keep reaching the same verdict: “Express is good enough for 99% of sites.” That’s broadly right. A typical CRUD API spends most of each request waiting on its database, not on routing, and a faster framework doesn’t change that.

What Express 5 fixed

Express 5.0.0 shipped in September 2024, about ten years after Express 4. On March 31, 2025, the Express Technical Committee made 5.1.0 the npm latest tag, replacing 4.21.2, and published an LTS strategy with three support phases. Express 5.2 followed on December 1, 2025. The current version on npm is 5.3.0, published in October 2026.

The change that matters most is async error handling. In Express 4, a rejected promise in an async route handler went uncaught unless you wrapped every handler or added a helper package. Express 5 sends rejected promises to your error middleware for you.

import express from 'express'

const app = express()
app.use(express.json())

app.get('/users/:id', async (req, res) => {
  const user = await db.findUser(req.params.id) // a rejection now reaches error middleware
  res.json(user)
})

app.use((err, req, res, next) => {
  res.status(500).json({ error: 'Something went wrong' })
})

app.listen(3000)

Express 4 vs Express 5: what changed

Most of Express 5’s breaking changes come from the router’s move to path-to-regexp v8 and from removing APIs that were deprecated long ago. Most apps need small fixes, not a redesign.

Area Express 4 Express 5
Minimum Node.js Very old versions supported Node.js 18+
Async errors Must call next(err) or use a wrapper Rejected promises go to error middleware automatically
Wildcard routes /files/* Must be named: /files/*splat
Optional parameters /:id? Brace syntax: {/:id}
Router engine Older path-to-regexp path-to-regexp v8
Body parsing bodyParser() combined helper available Combined bodyParser() removed; use express.json() and express.urlencoded()
Removed methods req.param(), res.sendfile(), app.del() available Removed; use req.params/req.query, res.sendFile(), app.delete()
Support status Maintenance only since April 1, 2025 Current, actively developed

Express 4 support status and what it means for old apps

Express 4 has been in maintenance since April 1, 2025: security patches and high-priority fixes only. The Express team set its end of life for no sooner than October 1, 2026, and that date has passed. The 4.x line still got maintenance releases this year, including v4.22.2 on May 11, 2026.

What that means for you:

  • An Express 4 app won’t break tomorrow. New security fixes for it are no longer guaranteed, though, so plan as if it’s already end-of-life.
  • Express 4 apps often run on old Node.js versions too, so you may face two upgrades: the framework and the runtime.
  • If you can’t upgrade soon, HeroDevs and TuxCare both sell paid extended support for end-of-life Express versions. Pricing is by quote only.

Signs you’ve actually outgrown Express

A switch is worth the cost when one of these is true:

  • You validate everything by hand. Fastify, Elysia and NestJS make schema validation part of the route definition.
  • Per-request overhead shows up in profiling on a hot path that doesn’t touch a database, such as a proxy or gateway.
  • You deploy to the edge. Express depends on Node’s http module, so it doesn’t run natively on Cloudflare Workers.
  • Your team keeps arguing about folder structure. NestJS ends those arguments with an opinionated layout.
  • You want end-to-end types shared between server and client without a code generator.

If none of these fit, upgrading to Express 5 is the right answer, boring as it is.

Express download numbers in context

By volume, Express is far ahead of every alternative. These figures come from third-party npm trackers, since npm itself doesn’t publish rankings.

Package Weekly npm downloads Period and source
express 102,442,714 Week of May 21-27, 2026 (PkgPulse)
@nestjs/core 9,967,129 Week of May 21-27, 2026 (PkgPulse)
koa About 3.7 million 2026 (DevPick tracker)

Much of Express’s volume comes from transitive installs: other tools depend on it, and NestJS uses it by default. PkgPulse rates Express’s trend as flat and Hono’s as the fastest-growing. Trackers disagree widely on Hono’s absolute numbers, so don’t lean on any single Hono figure.

Express alternatives compared at a glance

Fastify is the closest swap, Hono the most portable, NestJS the most structured and Elysia the most tied to Bun. Versions below were checked against npm and project release pages on November 16, 2026. “Migration effort” means the work needed to move an existing Express app.

Framework Latest version Minimum Node.js Runtimes Built-in validation TypeScript Learning curve Migration effort from Express
Express 5 5.3.0 18 Node.js None (add Zod or Joi) Community types (@types/express) Low Low (from Express 4)
Fastify 5.12.8 (v6 in alpha) 20 Node.js JSON Schema via Ajv Bundled types, type providers Low to medium Low to medium
Hono 4.13.18 (v5 prerelease) 20 (for @hono/node-server v2) Cloudflare Workers, Bun, Deno, Node.js, serverless Validator middleware with Zod and others Written in TypeScript Low Medium
NestJS 12.4.2 20.19+ or 22.12+ Node.js (Express or Fastify adapter) Pipes, class-validator, Standard Schema TypeScript-first High Medium to high
Koa 3.x 18 Node.js None Community types (@types/koa) Low Medium
Elysia 1.4.31 (2.0 release candidate) Bun first; Node.js via adapter Bun, Node.js (@elysiajs/node) TypeBox schemas TypeScript-first, inferred types Medium High

What they cost

Every framework in the table is free, open-source software. None charges per seat or per request. You pay for hosting and, if you want it, commercial support.

Product Current version Software price Paid options
Express 5.3.0 Free (open source) Extended support for EOL versions from HeroDevs or TuxCare: quote only
Fastify 5.12.8 Free (open source) Third-party consulting: quote only
Hono 4.13.18 Free (open source) None from the project; you pay your host (for example Cloudflare)
NestJS 12.4.2 Free (open source) Enterprise support and consulting via Trilon: quote only
Koa 3.x Free (open source) None
Elysia 1.4.31 Free (open source) None
Encore 1.58.8 (encore.dev) Framework free; Encore Cloud Starter free Encore Cloud Pro: $49 per member per month, plus $99 per AWS/GCP environment and $2.50 per resource

Fastify: the closest upgrade from Express

Fastify is the best Express alternative for most Node.js teams. Its routing feels familiar, it’s much faster per request, it has JSON Schema validation and Pino logging built in, and an official compatibility plugin lets you move one route at a time. Matteo Collina and Tomas Della Vedova started it, and like Express it’s an OpenJS Foundation project.

Fastify website
Screenshot: fastify.dev

How Fastify works differently

Fastify treats each route as a contract. You declare a JSON Schema for the request params, query, body and response. Ajv compiles that schema into a fast validator, and Fastify uses the response schema to serialize JSON faster than JSON.stringify. Logging comes from Pino, a low-overhead JSON logger from the same core team, and one option turns it on.

Instead of Express’s single middleware chain, Fastify uses lifecycle hooks such as onRequest, preHandler, onSend and onResponse. Plugins are encapsulated: a decorator or hook registered inside a plugin applies only to that plugin’s routes unless you choose to share it. This is the biggest mental shift for Express developers, and it’s what keeps large Fastify apps easy to reason about.

Express route vs Fastify route

Here’s the same GET /users/:id route with validation. In Express you’d bring Zod or Joi yourself. In Fastify the schema is part of the route:

import Fastify from 'fastify'

const app = Fastify({ logger: true }) // Pino logging on

app.get('/users/:id', {
  schema: {
    params: {
      type: 'object',
      properties: { id: { type: 'integer' } },
      required: ['id']
    }
  }
}, async (request) => {
  return { id: request.params.id } // returned objects are sent as JSON
})

await app.listen({ port: 3000 })

A request to /users/abc gets an automatic 400 response with a validation message, and you don’t write any error code for it. Handlers return values instead of calling res.json(), but reply.code(201).send(data) works when you need it.

Version status and Node.js requirement

Fastify v5 supports only Node.js 20 and newer. The current release is 5.12.8, which followed 5.12.7 (October 16, 2026). A Fastify 6 alpha appeared in August 2026. Under Fastify’s support policy, v5 keeps getting security fixes for six months after v6 ships, so starting a new v5 project now is safe. Put the v6 upgrade on next year’s roadmap.

Did you know?

Fastify 5.12.8 fixed a CVE in the framework’s handler timeout path, and TuxCare’s CVE tracker advises anyone on an earlier 5.x release to upgrade to 5.12.8 or later.

Check your runtime first

Run node -v before you pick a framework. Fastify 5, NestJS 12 and Hono’s Node adapter v2 all need Node 20 or newer, and Node 20 is end-of-life, so target a current LTS release.

Migrating with @fastify/express

The @fastify/express plugin gives Fastify an Express-style use(). Your existing Express middleware, such as cors or helmet, keeps running inside Fastify while you port routes.

import Fastify from 'fastify'
import expressPlugin from '@fastify/express'
import cors from 'cors'

const app = Fastify()
await app.register(expressPlugin)
app.use(cors()) // existing Express middleware still runs

Treat this as a bridge, not the finished setup. It adds overhead, and the native plugins (@fastify/cors, @fastify/helmet, @fastify/swagger) are faster and fit Fastify’s encapsulation model. Most simple request/response middleware works through the plugin. Middleware that relies on Express-only features like res.locals or req.app may not.

Mapping common Express middleware jobs

Every routine Express middleware job has a native equivalent in Fastify, Hono and Koa. Use this table to plan the replacement for each app.use() line in your current app.

Express job Typical Express code Fastify Hono Koa
Auth check Custom (req, res, next) function onRequest or preHandler hook, global or per route Built-in bearerAuth, basicAuth or jwt middleware Async middleware that checks before await next()
Request logging morgan Built-in Pino: Fastify({ logger: true }) Built-in logger() from hono/logger Timing middleware around await next(), or koa-logger
CORS cors @fastify/cors plugin Built-in cors() from hono/cors @koa/cors
Security headers helmet @fastify/helmet plugin Built-in secureHeaders() koa-helmet
Body parsing express.json() Built in for JSON; @fastify/formbody for forms Read in the handler with c.req.json() or c.req.parseBody() @koa/bodyparser
Error handler (err, req, res, next) middleware app.setErrorHandler() app.onError() try/catch around await next() in the first middleware
Static files express.static() @fastify/static serveStatic from the runtime adapter koa-static

Auth checks are what most teams get wrong in the port, because Fastify gives you two scopes. A global hook (app.addHook('preHandler', fn)) runs on every route in its plugin. A route-level hook runs only where you attach it:

app.decorateRequest('user', null)

async function requireAuth (request, reply) {
  const user = await verifyToken(request.headers.authorization)
  if (!user) {
    return reply.code(401).send({ error: 'Unauthorized' })
  }
  request.user = user
}

app.get('/me', { preHandler: requireAuth }, async (request) => request.user)

Want auth on a whole group of routes? Register those routes inside a plugin and add the hook there. Encapsulation keeps it off your public routes.

Limitations

  • Fastify runs on Node.js, not Cloudflare Workers.
  • JSON Schema is verbose. Most TypeScript teams add a type provider (for TypeBox or Zod) to get inferred types.
  • The plugin and encapsulation model takes a few days to learn properly.
  • The ecosystem is large but smaller than Express’s. A niche Express middleware may have no Fastify equivalent.

Fastify vs Hono: pick Fastify for a long-running Node.js server where validation, logging and plugins matter. Pick Hono when the same code has to run on edge or serverless runtimes.

Hono: for edge, serverless and running anywhere

Hono is the best Express alternative when your code has to run somewhere other than Node.js. It’s a small TypeScript framework built on the Web Standards Request and Response APIs, so one app runs on Cloudflare Workers, Bun, Deno, Node.js and the major serverless platforms. Yusuke Wada created it.

Hono website
Screenshot: hono.dev

How Hono works

A Hono app is just a fetch handler. Each runtime calls it with a standard Request, and Hono returns a standard Response. That’s why one codebase deploys almost anywhere. The smallest preset, hono/tiny, is under 14 kB, which matters on platforms where bundle size affects cold starts.

Routing looks a lot like Express. Middleware is async and follows Koa’s onion model: code before await next() runs on the way in, and code after it runs on the way out.

Express vs Hono: what changes in your code

import { Hono } from 'hono'
import { serve } from '@hono/node-server'
import { zValidator } from '@hono/zod-validator'
import { z } from 'zod'

const app = new Hono()

app.get(
  '/users/:id',
  zValidator('param', z.object({ id: z.coerce.number() })),
  (c) => {
    const { id } = c.req.valid('param') // typed as number
    return c.json({ id })
  }
)

serve({ fetch: app.fetch, port: 3000 }) // Node.js only; Workers and Bun just export app

Three things change from Express. One context object (c) replaces req and res. Handlers return a Response instead of writing to res. And validated input gets its type automatically. Hono also ships an RPC client, hc, that reads your route types, so a TypeScript front end can call the API with full type checking.

Version status and the Node.js adapter

Hono’s stable release is 4.13.18, and a v5 prerelease is in progress. Recent 4.13 patches have carried security fixes: 4.13.16 closed a hole where app.mount() could forward a path that skipped middleware scoped inside the mount prefix. Stay on the latest patch.

On Node.js, Hono runs through @hono/node-server. The package’s own documentation says v2 of the adapter is 2.3 times faster than v1. It keeps the v1 public API and requires Node.js 20 or newer.

Limitations

  • Express middleware doesn’t run in Hono. You’ll swap in Hono’s built-in middleware or rewrite it.
  • On Node.js specifically, Fastify has the more mature ecosystem for logging, plugins and OpenAPI.
  • Some Node APIs (filesystem, native modules) aren’t available on edge runtimes. That limits what your app can do there, but the limit comes from the runtime, not the framework.

Hono vs Elysia: Hono is runtime-neutral, which suits teams that haven’t committed to Bun. Elysia makes the opposite trade and tunes for Bun first.

NestJS: structure for big teams

NestJS isn’t really a replacement for Express. It’s an application framework that sits on top of an HTTP layer, and by default that layer is Express. Choose it when many developers share one codebase and need the same structure everywhere. Kamil Myśliwiec created it, and its design borrows from Angular.

Nest website
Screenshot: nestjs.com

How NestJS works

A NestJS app is built from modules that group related features. Each module has controllers for routes and providers for business logic, and NestJS’s dependency injection container wires them together. Decorators declare routes, parameters, guards and validation:

import { Controller, Get, Param, ParseIntPipe } from '@nestjs/common'

@Controller('users')
export class UsersController {
  constructor(private readonly users: UsersService) {}

  @Get(':id')
  findOne(@Param('id', ParseIntPipe) id: number) {
    return this.users.findOne(id) // returned value is serialized to JSON
  }
}

That’s more code than an Express route. In return you get consistency. Every feature in a 50-developer codebase looks the same, injected mocks make testing easy, and official packages cover GraphQL, microservices, WebSockets and OpenAPI docs.

Express 5 or Fastify underneath

NestJS 11 made Express 5 the default HTTP adapter. That brought in Express 5’s routing rules, so a wildcard such as files/* has to become files/*splat. For Fastify’s speed, swap in @nestjs/platform-fastify and keep your controllers. Code that touches the raw Express req and res objects won’t carry over.

Rename bare wildcards

Before you upgrade to Express 5 or NestJS 11+, search your routes for bare * wildcards and give them names, for example /files/*splat. Unnamed wildcards fail under path-to-regexp v8.

NestJS 12 changes

NestJS 12.0.0 shipped in late August 2026, and the current release is 12.4.2. The core packages are now ESM-only. CommonJS apps keep working through Node’s require(esm) support, which is why apps need Node.js 20.19+ or 22.12+. The CLI and nest upgrade need an even newer runtime: 22.22.3+, 24.15+ or 26+. Version 12 also adds Standard Schema validation and built-in observability, and nest upgrade moves projects to TypeScript 6. Since then, 12.2.0 (October 19, 2026) added field-nesting limits to the Express and Fastify adapters.

Do you need NestJS, or is it overkill for a solo project?

For a solo project or a small API, it’s usually overkill. Modules, providers and decorators add ceremony before you’ve written any business logic. NestJS pays for itself when several teams work in one service, when you need its microservice or GraphQL tooling, or when your developers come from Angular, Spring or .NET and expect dependency injection.

Limitations

  • It has the steepest learning curve on this list.
  • It leans heavily on decorators, which adds indirection when you debug.
  • It’s tied to Node.js. The ESM move in v12 can trip up Jest setups and AWS Lambda deployments.

NestJS vs Fastify: they don’t really compete, since you can run NestJS on Fastify. Choose NestJS for architecture and Fastify for a lean HTTP layer.

Koa: the Express team’s minimalist follow-up

Koa is a minimal framework from the team behind Express. It was designed around async/await from the start and ships with almost nothing built in. It suits developers who want a small core and like choosing every piece themselves. Koa isn’t dead: it’s on a maintained 3.x major line and still draws about 3.7 million weekly downloads.

Koa website
Screenshot: koajs.com

How Koa works

Koa gives each request one ctx (context) object and runs middleware as an async “onion,” where each layer can run code both before and after await next(). That makes timing, error handling and response rewriting cleaner than Express’s callback chain. There’s no router, body parser or static file serving built in. You add packages like @koa/router.

const Koa = require('koa')
const Router = require('@koa/router')

const app = new Koa()
const router = new Router()

app.use(async (ctx, next) => {
  try {
    await next() // errors from any later middleware land here
  } catch (err) {
    ctx.status = err.status || 500
    ctx.body = { error: err.expose ? err.message : 'Something went wrong' }
  }
})

router.get('/users/:id', (ctx) => {
  ctx.body = { id: ctx.params.id } // objects are sent as JSON
})

app.use(router.routes()).use(router.allowedMethods())
app.listen(3000)

The first middleware does the job of Express’s four-argument error handler. Because it wraps everything after it, one try/catch covers every route.

What changed in Koa 3

Koa 3 requires Node.js 18 or newer and drops the old generator-style middleware, so legacy middleware has to be rewritten as async functions. It also changes the ctx.throw() signature, replaces ctx.redirect('back') with ctx.back() and moves query parsing to URLSearchParams.

Limitations

Koa’s real weakness is momentum, not maintenance. Hono offers the same ctx-and-onion model plus TypeScript inference and multi-runtime support. Koa has no built-in validation, and Express middleware doesn’t run in it unchanged.

Koa vs Hono: same minimalist philosophy. Pick Koa for an existing Koa codebase or if you prefer plain JavaScript on Node.js. Pick Hono for new TypeScript work.

Elysia: Bun-first and type-safe

Elysia is a TypeScript framework built for Bun. Its headline feature is type inference: you define a route’s schema once with TypeBox, and Elysia uses it for validation, TypeScript types and OpenAPI docs. It suits new projects that have already chosen Bun.

Elysia website
Screenshot: elysiajs.com

How Elysia works

import { Elysia, t } from 'elysia'

new Elysia()
  .get('/users/:id', ({ params }) => ({ id: params.id }), {
    params: t.Object({ id: t.Numeric() }) // validated and typed as number
  })
  .listen(3000)

The t builder is TypeBox, a library that produces JSON Schema and TypeScript types from one definition. Elysia’s Eden client then shares those types with your front end, much like Hono’s RPC client.

Version status

The stable release is 1.4.31, and the 1.4 line now gets security updates only, with no new features. Elysia 2 is a full rewrite. The team announced the Elysia 2 release candidate on October 19, 2026, and 2.0.0-rc.1 is the current build on the next tag, with a codemod for migration. Stable 2.0.0 hasn’t shipped yet. For a long-lived production project, start on 1.4.31 or wait for 2.0.0.

Did you know?

The Elysia team’s own Elysia 2 RC announcement says the rewrite’s big gains are much lower memory use and faster startup, not raw request speed, and that the RC came about two months late because of extra testing.

Limitations

  • Bun is the main target. You can run on Node.js through @elysiajs/node, but that adapter’s README says it isn’t feature-complete yet, and WebSocket support is among the missing pieces.
  • It has the smallest ecosystem and contributor base of the main six.
  • Moving from Express means a new runtime plus a rewrite, which makes it the most expensive move on this list.

Elysia vs Hono: Hono runs well on Bun too. If there’s a real chance you’ll leave Bun later, Hono is the safer bet.

Other options worth knowing: hapi, Restify, Encore, Feathers, h3

These five fit narrower needs. Each is a sound choice in the right situation, but none is the default pick for a typical Express app.

hapi

hapi is a configuration-driven framework that grew out of Walmart Labs. Routes are declared as objects, and input validation (usually joi), authentication and caching are set in each route’s options rather than in middleware. The 21.x line officially supports Node 18 and added ESM compatibility. The maintainers support only the latest release of the current major, and each major gets at least a year of support. hapi suits enterprise REST APIs that value explicit configuration over speed. Moving from Express means rewriting your routes.

hapi website
Screenshot: hapi.dev

Restify

Restify is built only for REST APIs, with features like versioned routes and DTrace-friendly observability. Its API looks like Express, so porting is simple. It now releases far less often than Fastify, so check its recent activity before you commit. For a new REST API, Fastify covers the same ground with more momentum.

Restify website
Screenshot: restify.com

Encore

Encore.ts is an open-source TypeScript backend framework with a Rust-based runtime. The current release is v1.58.8, and that’s also the version of the encore.dev npm package. It works on “infrastructure from code”: you declare databases, queues and cron jobs in TypeScript, and Encore provisions them. The company behind it sells Encore Cloud. The Starter tier is free. Pro costs $49 per team member per month, plus $99 per AWS or GCP environment and $2.50 per resource in each environment. Encore’s own pricing example puts three members, one environment and ten resources at $271 a month. It suits teams that want a framework and a deployment platform in one, and it ties you to a vendor more than anything else here.

Encore website
Screenshot: encore.dev

Feathers

Feathers is a framework for REST and real-time APIs. It can use Express or Koa as its HTTP layer, so an Express shop can adopt it without throwing out its middleware. It fits apps built around real-time updates over WebSockets.

Feathers website
Screenshot: feathersjs.com

h3

h3 is a minimal HTTP framework from the UnJS project and the server layer under Nitro and Nuxt. Its v2 line moves to Web Standard Request and Response, like Hono. It mostly makes sense if you already work with Nuxt or Nitro.

h3 website
Screenshot: h3.dev

What about speed? Reading the benchmarks honestly

Fastify, Hono and Elysia all beat Express in raw request benchmarks, by roughly three to five times. The ranking changes once schema validation is switched on, though. The most-cited numbers also test old versions, and in a real app your database decides speed far more than your framework does.

Benchmark snapshot (with version caveats)

These figures come from Encore’s own comparison of Express alternatives, and the test code is in Encore’s public encoredev/ts-benchmarks repository on GitHub. Encore is a competing vendor, and the versions tested date from 2024. The chart reports two results for each framework: a plain JSON endpoint without validation, and the same endpoint with schema validation on.

Framework + validator Versions tested Requests per second, without validation Requests per second, with schema validation
Express + Zod Express 4.19.2 15,707 11,878
Fastify + Ajv Fastify 4.27.0 62,207 48,397
Hono + TypeBox Hono 4.6.3 71,202 33,150
Elysia + TypeBox Elysia 1.1.16 82,617 35,124

Look at the second column. Elysia leads the plain test, but with validation on, Fastify comes first of the four, about 38% ahead of Elysia and 46% ahead of Hono. Ajv compiles each schema into a validator function ahead of time, and that pays off on every request. Validation also takes the smallest share of Express’s throughput in absolute terms, but Express starts from a much lower base, so it stays last in both columns.

Elysia’s team disputed Encore’s setup and reran the benchmark in November 2025, reporting much better results for Elysia. Read that as one vendor answering another, not as an independent result.

Why these numbers mislead

  • Old versions. The test uses Express 4 and Fastify 4, and Express 5 and Fastify 5 have been the defaults for more than a year.
  • Validation changes the order. Fastify ranks first among the four once schema validation is enabled, and real APIs almost always validate input. A chart that shows only the no-validation column favours Bun-first frameworks.
  • Hello-world workloads. Throughput tests measure framework overhead on near-empty handlers. Add a 5-millisecond database query and the framework’s share of each request shrinks to almost nothing.

So when does speed really matter? For high-volume gateways, proxies, authentication edges and services that answer mostly from memory. There, Fastify on Node.js or Hono and Elysia on Bun can cut server costs. For a typical CRUD API, a database index or a cache will do more than a framework swap.

How to migrate off Express without a rewrite

Migrate in this order: runtime first, then Express 5, then the new framework one route at a time. Each step can ship on its own, so production never waits on a big-bang rewrite.

Before you start

Make sure your test suite covers your main routes and error responses, and tag a release you can roll back to. A framework migration changes error formats and status codes in small ways that tests catch and manual checks miss.

Upgrading Express 4 to 5 first

Even if Fastify or Hono is the end goal, upgrading to Express 5 first is the cheapest way to cut risk. It gets you off an end-of-life line and gives you automatic async error handling right away.

Upgrade Express 4 to Express 5

  1. Run node -v and move to a current Node.js LTS release (Express 5 needs 18+, but Node 18 and 20 are both end-of-life).
  2. Replace any bodyParser() call with express.json() and express.urlencoded().
  3. Run the official codemods with npx @expressjs/codemod upgrade to fix renamed APIs.
  4. Rename bare wildcards (/* becomes /*splat) and rewrite optional params (/:id? becomes {/:id}).
  5. Replace req.param(), res.sendfile() and app.del() with req.params, res.sendFile() and app.delete().
  6. Install express@5, run your tests and remove any async-wrapper helpers you no longer need.

Fix body parsing first

Swap bodyParser() for express.json() and express.urlencoded() while you’re still on Express 4. It works on both versions, so it’s one less change on upgrade day.

Moving route by route

The strangler pattern sends traffic for one endpoint at a time to the new framework while the old app keeps handling everything else. You can run it in two ways:

  1. Inside one process (Fastify). Create a Fastify app, register @fastify/express and mount your existing middleware. Port one route group to native Fastify with a schema, ship it, then do the next. The table in “Mapping common Express middleware jobs” (in the Fastify section) shows the replacement for each app.use() line. Once nothing depends on Express middleware, remove the plugin.
  2. Behind a proxy (Hono, Elysia, NestJS or anything else). Run the new service alongside the Express app. A reverse proxy or API gateway routes a path prefix, such as /v2/users, to the new service. Move prefixes across until the Express app handles nothing, then retire it.

Testing checklist for each ported route

  • Same status codes for success, validation failure, not found and server error.
  • Same JSON error body shape. Fastify’s and Hono’s default validation errors won’t match whatever you built in Express.
  • Same headers, especially the CORS, cache and security headers your middleware used to set.
  • Same handling of trailing slashes and case in paths.
  • Logs and request IDs still reach your monitoring.

Each framework has an in-process test helper, so you don’t need a running server: supertest for Express, app.inject() for Fastify and app.request() for Hono.

Migration effort by framework

Target Effort Why
Express 5 Low Same API; mostly route-syntax and removed-method fixes, with codemods available
Fastify Low to medium @fastify/express runs old middleware; handlers change to return values
NestJS Medium to high Express runs underneath, but code moves into modules, controllers and providers
Koa Medium Small API, but ctx replaces req/res and Express middleware won’t run
Hono Medium Familiar routing; middleware and Node-specific code need rewriting
hapi High Config-object routes and a different plugin model
Elysia High New runtime (Bun) plus a rewrite to TypeBox schemas

Which one should you pick?

Match the framework to your situation, not to a benchmark chart. This table covers the most common cases.

Your situation Pick Why Watch out for
Existing Express 4 app that works Express 5 Smallest change, off the end-of-life line Wildcard and optional-param syntax
New REST API on Node.js Fastify Validation, logging and speed built in; fastest of the four with validation on Node 20+ only; v6 upgrade next year
Coming from Python FastAPI Fastify or Elysia Schema-first routes and OpenAPI generation, like Pydantic JSON Schema verbosity in Fastify
Cloudflare Workers, Deno or serverless Hono Runs on Web Standards in every major runtime No Express middleware
Large team, many services NestJS Enforced structure, DI, official tooling Ceremony and the v12 ESM changes
Greenfield on Bun with shared types Elysia Inferred types and Eden client Node adapter incomplete; 2.0 still a release candidate
Existing Koa codebase Koa 3 Maintained, minimal, async-first Generator middleware removed in v3
Config-heavy enterprise API hapi Validation and auth set in each route’s options Rewrite from Express
Want infra provisioning included Encore Framework plus deployment platform Vendor coupling; Pro costs $49 per member a month

Why do beginner tutorials still use Express?

Express has the smallest API to learn, the most Stack Overflow answers and over a decade of examples. What you learn there (routing, middleware, request and response) carries straight over to Fastify, Koa and Hono, so beginners lose nothing by starting with it. Just learn Express 5, not from tutorials written for Express 4.

The honest counter-argument

Switching frameworks feels productive, but a migration can eat weeks and give users nothing new. If your Express 5 app is stable and fast enough, and your team knows it, the strongest argument for staying is that the time is better spent elsewhere. Switch when one of the signs listed in “Signs you’ve actually outgrown Express” applies, not because a benchmark looks impressive.

Looking for ExpressVPN alternatives instead?

If you searched “alternatives to express” for a VPN, this isn’t the page you want. ExpressVPN is a consumer VPN service with no connection to Express.js. The Tech Blog’s security coverage compares VPNs on privacy policy, price and speed. The same search also catches people looking for other kinds of “express,” like express shipping or express checkout. The frameworks above only matter if you’re building a web server.

FAQ

Is Express.js dead in 2026?

No. Express 5 is actively maintained and is still the most-downloaded Node.js framework. Express 4 is the version to leave, since its earliest end-of-life target has passed (see “Express 4 support status and what it means for old apps”).

Is it still recommended to use Express?

Yes, as long as it’s Express 5, for APIs and server-rendered apps that don’t need built-in validation, edge deployment or enforced structure.

What are some good alternatives to Express.js?

Fastify for fast Node.js APIs, Hono for edge and multi-runtime apps, NestJS for large structured codebases, Koa for minimalists and Elysia for Bun. hapi, Restify, Encore, Feathers and h3 fit narrower needs.

Is Fastify better than Express?

Fastify is better for new APIs that need schema validation, structured logging and high throughput. Express 5 is better when you depend on its middleware ecosystem or your team knows it well. The @fastify/express plugin lets you move gradually.

Express vs Hono: which should I use?

Use Hono for Cloudflare Workers, Bun, Deno, serverless or typed TypeScript routes. Use Express on a traditional Node.js server that relies on Express middleware, because that middleware won’t run in Hono.

Is NestJS an alternative to Express or built on it?

Both. It has its own architecture but runs on Express 5 by default, and you can switch it to Fastify with @nestjs/platform-fastify.

Is Koa still maintained?

Yes. Koa is on its 3.x line and requires Node.js 18+. Few new projects choose it, but it isn’t abandoned.

Should beginners still learn Express?

Yes. It teaches the routing and middleware ideas every Node.js framework uses. Make sure your course or tutorial covers Express 5.

What is the fastest Node.js framework?

It depends on whether validation is on. In Encore’s published benchmark without validation, Elysia leads (82,617 requests per second), followed by Hono (71,202) and Fastify (62,207). With schema validation on, Fastify + Ajv comes first at 48,397, ahead of Elysia (35,124) and Hono (33,150). Those tests use 2024 versions and near-empty handlers, so the gaps shrink a lot in a real app with a database.

Will my Express middleware work in Fastify?

Most standard middleware, such as cors and helmet, runs through @fastify/express. For the long term, switch to the native plugins listed in the table under “Mapping common Express middleware jobs.”

From Python FastAPI to Node.js: what framework should I use?

Fastify is the closest match on Node.js, with schema-first routes, automatic validation and OpenAPI docs through @fastify/swagger. If you’re open to Bun, Elysia’s TypeBox schemas feel a lot like Pydantic models.

Next step

Run node -v and npm ls express on your project today. If either shows an end-of-life version, make moving to a current Node.js LTS release and Express 5 your next sprint, whichever framework you end up on. Then find your situation in the decision table and port one low-risk route, such as a health check or a read-only endpoint, to see how the new framework fits your codebase before you commit.