Express is a routing and middleware framework built on Node.js, and our source run passed all 1,290 tests. Use it if you want to choose your own backend components. Skip it if you want a framework that supplies your database integration and application conventions: Express leaves that assembly to you. Its middleware guide describes a deliberately small request-processing layer, while Stubbs describes the additional components a complete backend needs.
What people use Express for
Express can coordinate backend requests, and the clearest business example is Stubbs's digital asset management project, which combined Express, NestJS and MongoDB.
| Who used it | What they did | What the account actually demonstrates |
|---|---|---|
| Stubbs team | Built a digital asset management backend with Express, NestJS and MongoDB | Its Express layer coordinated fiat on/off-ramp workflows, KYC/KYB identity checks and corporate wallet access controls, according to Stubbs's project account. |
| Express maintainer dougwilson | Wrote production Express applications using ES6 JavaScript | He answered a compatibility complaint by saying he used ES6 in production; issue #3913 records that experience. |
| GitHub commenter nook-scheel | Used application inheritance to separate modules | They asked maintainers to retain inheritance because their module separation used it; issue #1838 records the dependency and a maintainer's request for more detail. |
The Stubbs example is useful because it names the work behind a vague phrase such as “fintech backend.” Receiving a provider callback, checking who can access a corporate wallet and coordinating an identity check are specific responsibilities. Express supplies the HTTP layer around that work. The identity provider, payment services and database remain separate systems. Stubbs is reporting its own client project, so read this as an implementation account rather than an independent endorsement.
The other examples answer narrower questions. dougwilson's production experience rebuts the idea that Express applications must wait for the framework's own source code to adopt newer JavaScript syntax. nook-scheel's comment shows how an application can depend on a framework behavior during a migration discussion. The response asks why routers would not serve that purpose; it isn't a completed migration story. Both are more useful than counting every mention of the word Express as adoption.
What happened when we ran it
Our source run installed dependencies in 23 seconds and passed 1,290 Mocha tests in 6 seconds; a separate README-snippet task printed a server-start message, then timed out.
The snippet run used the README's 11-line JavaScript block from “Table of contents,” executed without edits in a fresh, unprivileged container with no published ports or secrets. Its run record identifies November 20, 2026 and commit 43fca52d28a4. The lab first completed its quickstart-lib clone step, then installed the npm package before running the block.
The process printed Server is running on http://localhost:3000. It was still running when the snippet task timed out after 120.1 seconds. The automated finding called this “the README snippet does not run as written”. That wording goes further than the observed outcome: the command failed the task's completion deadline after announcing a listening server. A request-and-response check would be the useful next measurement. The teardown completed successfully.
The source checkout was a separate test, using the recorded configuration of 3 CPUs, 8 GB RAM and image label lab-node:22 at commit 43fca52 on November 20, 2026. These are our harness results for the source checkout:
| Source checkout step | Our result | What you should take from it |
|---|---|---|
| Dependency installation | Succeeded in 23 seconds; 351 dependencies recorded; 67 MB on disk | This is a repository development environment, rather than a footprint for every application using Express. |
| Build | No build script or target; skipped | There was no build result to grade. |
| Tests | Succeeded in 6 seconds; 1,290 passed, 0 failed out of 1,290 | The recorded Mocha suite passed at this commit. |
| npm audit | 0 known vulnerabilities at every recorded severity | The audit result describes that dependency snapshot. |
| Repository scan | 216 files, about 22,188 source lines, 0.7 MB checked out | The source checkout is distinct from installed dependencies. |
| Delivery signals | 5 CI workflow files, a tests directory, no Dockerfile | A framework checkout leaves container packaging to your application. |
We measured 1,290 passing tests in our source run, so you can work on this checkout without first repairing a failed suite. It says less about the service you will assemble around it. The snippet timeout is also a useful reminder for anyone testing server examples: a process-exit condition and an HTTP success condition ask different questions.
Where people get stuck: control flow and route order
A middleware function must finish the response or pass control onward, otherwise the request hangs, according to the Express middleware guide.
Middleware means a function that gets a chance to inspect or change a request and response before another handler runs. That model stays understandable when each function has a clear exit path. It becomes harder to follow when a permission branch sends nothing, or a function starts background work and nobody owns its failure. Before changing infrastructure to diagnose a hanging endpoint, follow the path through its handlers.
| Symptom | What the source says | Practical response |
|---|---|---|
| Request never completes | Middleware neither ends the response nor calls next() in the official guide |
Make every applicable path respond or transfer control. |
| JSON body is missing | The tutorial registers express.json() before reading req.body in its request-body example |
Put the JSON parser before handlers that consume JSON. |
/book/create reaches an ID handler |
MDN warns that /book/:bookId can also match that literal path in its routing lesson |
Register the specific create route first. |
| A promise rejection escapes | A promise started without being returned needs explicit forwarding in the error guide | Return the promise or attach .catch(next). |
The history can confuse newcomers. In issue #2211, the author wanted body parsing bundled again after middleware was removed from Express. That historical request is a poor substitute for today's parser instructions: the newer tutorial uses built-in express.json(). JSON parsing and file-upload handling are separate decisions.
Express 5 catches returned promises, including async handlers
Express 5 automatically forwards errors from rejected promises returned by handlers, and async functions return promises, according to its error-handling documentation.
That gives you a direct way to write a handler which awaits a database call and then sends its result. If the awaited operation rejects, Express can send that error into its error-handling path. You still need to decide what error response your API should expose. Automatic forwarding removes repetitive plumbing; it doesn't design the public error contract.
The boundary is the returned promise. Start a promise chain without returning it and Express cannot track it. The docs show .catch(next) for that case. Callback APIs also need their error passed to next, and exceptions thrown inside a timer need to be caught inside that asynchronous callback. “Async support” is too broad a phrase to replace those distinctions.
The older promise discussion in issue #2259 proposed having next() return a promise and propagating returned promises through middleware. Today's documentation supports a specific conclusion about handler rejection forwarding. It doesn't turn every historical proposal in that thread into a shipped feature. If you're updating old application code, examine how each asynchronous operation hands control back.
CPU work still hurts other requests
CPU-intensive code that blocks Node's event loop can delay other requests, a workload warning explained in the Packt chapter on Express use cases.
The event loop is the mechanism Node uses to coordinate work such as network requests while waiting for outside operations. A handler doing lengthy synchronous computation keeps that loop busy. A small routing framework doesn't remove that constraint. For you, the architectural question is where expensive computation runs and how HTTP handlers wait for its result. The chapter favors Express for applications coordinating I/O, such as databases and external services.
Memory reports deserve the same care about attribution. The author of issue #3552 reported production memory growth that triggered alerts and restarts, then observed similar behavior with a plain Node HTTP server. dougwilson said neither he nor the Node core team could reproduce the leak locally and asked for a reproducible case. The issue is closed, but the discussion does not identify an Express fix. Reproduction and heap snapshots, which show the objects retained in memory, are the next useful evidence when investigating that report.
Security requires more than a clean dependency audit
Our npm audit recorded 0 known vulnerabilities, while the Stubbs implementation account describes authentication, authorization and secrets management as additional backend responsibilities.
Express's small scope makes that distinction especially consequential. A route existing doesn't tell you whether the caller may access the requested record. Parsing JSON doesn't establish that its contents are acceptable. For a wallet or a business API, your team must choose the checks, place them in the request path and decide what gets logged. Stubbs explicitly says the framework does not automatically ensure compliance.
The default error handler also needs attention. The official error guide says production responses omit stack traces when NODE_ENV is set to production. Put that setting and your application's error responses into the deployment checklist. A clean audit is useful dependency evidence; it can't answer whether a permission check was omitted from a route.
Maintenance has current dates and a human cost
GitHub lists Express v5.3.0 as published on October 9, 2026, and records a repository push on November 19, 2026.
The latest-release API and repository API give that dated picture. The latter showed 69,671 stars and 262 open issues and PRs. Stars count attention, and the open count includes pull requests. The old “is express dying?” issue #2844 is historical community concern, rather than a current release calendar. In #3913, dougwilson also responded directly to complaints about inactivity and asked what specific change the user needed.
Maintainer attention has competing demands. In issue #5449, wesleytodd described removing spam comments and blocking accounts. UlisesGascon pointed out that watchers receive notifications before a GitHub Action can run. Maintainers rejected the proposed action, citing maintenance and security costs, and closed that specific proposal. They didn't declare the wider spam problem solved. If your adoption decision depends on support, distinguish visible repository activity from a promise that someone will handle your application's incident.
Express vs Fastify, NestJS, Next.js, FastAPI and raw Node
Express adds routing and middleware to Node's HTTP facilities; NestJS can itself run on Express, so those choices can coexist.
| Alternative | The decision it changes | When to look at it |
|---|---|---|
| Raw Node HTTP | You implement the HTTP handling directly | Mr Madhukar's routing tutorial considers it reasonable for tiny scripts or learning HTTP fundamentals. |
| Rails, Django or CakePHP | You choose a fuller framework instead of assembling supporting components | The Packt chapter favors that approach for CRUD applications with complex database relationships. CRUD means creating, reading, updating and deleting records. |
| Fastify | Its README recommends JSON Schema for route validation and output serialization | Consider it when you want those schemas to guide your API design, as described in Fastify's core features. |
| NestJS | Adds modules and dependency injection, which supplies configured components to application code | Consider it when you want shared application structure; its README documents Express among its HTTP options. |
| An optimized Express router fork | Trading compatible behavior for router changes can affect a benchmark | In issue #2218, maintainers wanted speed gains without losing features and encountered a router-mounting error. |
For Express vs Node or Express vs Node.js, choose how much HTTP plumbing you want to write. For Express vs NestJS, choose who defines the application structure. For Express vs Fastify, schema handling is a concrete point to examine before comparing speed claims. Those are useful differences even without a leaderboard.
Next.js and FastAPI also appear in framework comparison searches. This review has no common-workload result that ranks Express against Fastify, NestJS, Next.js or FastAPI. The historical router fork discussion illustrates why matching behavior matters: a faster partial implementation isn't automatically a replacement for the application you already have.
What the other reviews get wrong
Algoscale's Express-versus-Node framing obscures that Express runs on Node, and WeblineIndia's relational-database claim gives Express credit for work done by separate components.
Algoscale's comparison concludes that Express is the better server-side choice. The meaningful choice is using Express or writing against Node's HTTP facilities directly. Its own dependency on Node makes a blanket runtime-versus-framework winner misleading. The Express handbook identifies the relationship plainly.
Algoscale also promises easy scaling for any Express web application. That exceeds what the framework can deliver: the Packt workload warning explains how blocking CPU work holds up requests. A routing choice cannot excuse the work a handler performs.
WeblineIndia's German-language article says developers address relational-database support limitations with Express. Express itself adds no database. Stubbs's account explicitly separates the framework from database and ORM components. An ORM is a library that maps application objects to database operations. Choose that component on its own merits.
Questions people ask
Yes, Express suits a future project when you want a small HTTP layer and can own the supporting backend components described in Stubbs's architecture account.
Should I use Express for future projects?
Use Express when your team already has decisions for authentication, persistence and request handling. The official middleware guide defines its small scope, and Stubbs names the systems you add around it. The cost is maintaining those choices together as the application changes.
Is Express still actively maintained?
Yes: GitHub records a November 19, 2026 push and lists v5.3.0 published on October 9, 2026 in its repository facts and latest release. The historical inactivity threads are useful context for community expectations, rather than evidence of current abandonment.
How does Express compare with Fastify, NestJS, Next.js and FastAPI?
Express provides routing and middleware. Fastify recommends route schemas, while NestJS supplies application structure and can use Express underneath. The comparison table explains those design choices; comparable performance and migration results belong in a workload test.
What is the difference between Express and Node.js?
Node.js is the underlying runtime; Express is a web framework built on it. The Express handbook describes that relationship, and the routing tutorial shows how Express replaces manual URL and method checks with route declarations. “Express JS” refers to this JavaScript framework here.
When is raw Node.js a better choice than Express?
Raw Node is reasonable for a very small script or for learning how HTTP servers work, according to Mr Madhukar's tutorial. That choice gives you the lower-level request interface directly. More routes make Express's method-and-path declarations increasingly useful for organizing handlers.
Can Express applications use ES6 and async/await?
Yes: dougwilson reports writing production Express applications in ES6 in issue #3913, and the Express 5 error guide demonstrates async handlers with automatic rejection forwarding. Application syntax support and whether the framework's own source uses that syntax are separate questions.
How do I read a request body in Express?
Register express.json() before handlers that read a JSON body from req.body, as shown in the request-body tutorial. That answer concerns JSON. Choose a parser appropriate to the incoming format instead of treating a JSON parser as a general file-upload solution.
Do I need express.json() for every route or just POST routes?
Use it where handlers need JSON request bodies, typically POST, PUT or PATCH. The tutorial's FAQ says global registration through app.use() is also possible when some routes don't use it. Registering once before the relevant handlers avoids repeating the parser on each route.
What is the difference between res.send() and res.json()?
res.send() handles text, HTML and objects, while res.json() explicitly sends JSON, according to the routing tutorial's response examples. An object passed to res.send() can also become JSON. Choose the explicit method when your endpoint's response is intended to be structured JSON data.
Can the same Express path handle both GET and POST requests?
Yes: define app.get() and app.post() for the same path separately. The routing tutorial explains that Express matches both the HTTP method and the path. A shared URL doesn't require putting both operations into one handler with manual method checks.
How do I build an Express backend and learn routing and middleware?
Start with routes organized by resource, then follow how middleware passes control to their handlers. MDN's LocalLibrary lesson builds modular routes and controllers with dummy responses before connecting them to model data. That sequence lets you understand URL handling before adding the database behavior.
Is the reported server memory growth caused by Express or Node.js?
Issue #3552 doesn't settle the cause. Its reporter also saw growth with plain Node HTTP, while dougwilson asked for a reproducible leak. Treat a production memory alert as a reason to collect heap evidence for your application, rather than as proof that this old thread diagnosed your problem.
What we have not tested yet
Our passing source suite and the snippet's timeout do not establish production throughput, memory stability or a successful HTTP response from the example server.
The snippet task used 2 CPUs and 4 GB RAM, while the source harness used 3 CPUs and 8 GB. Its npm-package task and the source checkout are different scopes. Only the source harness figures are used here for installation, dependency size, tests and audit results. The lab-node:22 label is recorded configuration; actual runtime and operating-system versions require the toolchain logs.
There is no shared workload here comparing Fastify, NestJS, Next.js or FastAPI, no measured migration effort and no sustained traffic test. The Stubbs account supplies responsibilities, rather than traffic, latency, reliability or cost results. The inheritance thread ends without a migration outcome, and the old memory thread lacks a confirmed cause. Current release and push dates don't measure contributor capacity or a support response guarantee.
The autocomplete list mixes the framework with unrelated searches. Express Avenue and Express Avenue PVR concern a different entity from Express JS. Expression meaning in Hindi, expression, expresso, expressvpn, express delivery and expresso car are outside this software review. Express vs superfast and express vs superfast train aren't framework comparisons. Those terms provide no evidence about this repository.
The Reddit threads concern other products or services, the X results aren't framework experience, and the YouTube transcripts don't show Express backend work. No adoption or reliability conclusion is drawn from them. The next useful lab task is a request that checks a response, followed by an application workload with its database and middleware choices recorded.


