Our NestJS contributor checkout passed all 4,940 tests; a later attempt to run the README snippet under tsx failed with TransformError. This nest review covers the TypeScript backend framework in nestjs/nest. Those two results concern different commits and execution paths. The adoption decision is whether your team wants Nest's shared modules and dependency injection enough to take responsibility for connecting its application dependencies.
Short answer: the checkout passed, the tsx snippet attempt failed
Our October contributor checkout passed its suite, while the November tsx attempt stopped before the README example could serve requests. Use NestJS when shared backend conventions solve a problem your team already has. Keep your existing Express or Fastify structure when it serves the team well and adopting Nest's module model would add work without a clear purpose.
A useful first adoption exercise is one route backed by your actual database integration, with that dependency replaced in a test and the intended authentication path exercised. This connects the framework choice to work the application needs. The supplied issues repeatedly concern those connections: a missing model in a testing module, a validator using a different container, or authentication completing after a socket has connected.
What people use nest for
Participants in Nest's production discussion describe company products, an internal management application and a communications dashboard. Their accounts give concrete examples of the jobs developers assigned to Nest and the benefits they reported. They also help distinguish an architectural preference from a requirement: retrieving CMS content and maintaining a call-centre dashboard are different applications, even when both teams choose the same framework.
| Who reported it | What they built | Reported outcome |
|---|---|---|
| RecuencoJones, discussing adidas.github.io | A backend retrieving GitHub metadata and CMS content | Liked its simplicity and TypeScript support. Production discussion |
| nartc at ArchitectNow | Two company products using NestJS | Reported that their boss liked it. Production discussion |
| alsoicode, working for Day & Zimmermann through Also, I Code | An internal management application using Nest, MongoDB and Angular | Described organizational use. Production discussion |
| gregmagolan and lead developer yharaskrik at Trellis | A product with an Angular frontend | Liked sharing a language between client and server. Production discussion |
| mariolenis at Kerberus | A Callcenter & PBX dashboard | Reported migration resistance followed by appreciation of maintenance and architecture benefits. Production discussion |
The Kerberus account connects the decision to a team problem. Mariolenis says convincing colleagues to migrate was difficult, then describes advantages for code maintenance and architecture. A team struggling to find business logic across differently organized services can use that account to frame its own evaluation. The question is what shared structure would improve in the existing code, rather than whether another company has adopted Nest.
RecuencoJones describes a backend retrieving GitHub metadata and CMS content, while the Trellis developers value using the same language on both sides of their application. These accounts suggest different reasons to consider Nest. Before migrating, name your own reason just as plainly: shared service boundaries, a consistent testing approach, or a common language across the application. That makes the first implementation exercise easier to judge.
What happened when we ran it
Our November 17 attempt ran the README's unedited TypeScript snippet with tsx and failed with TransformError. The run used checkout 085f83a168e9 and the quickstart-lib recipe. Its fresh unprivileged container had image label lab-node:22, 2 CPUs and 4 GB RAM, with no published ports or secrets. The recipe installed @nestjs/core from npm rather than generating an application with the CLI.
| Question | Answer | Verdict | Why |
|---|---|---|---|
| Did the recipe obtain the source? | Clone completed in 2 seconds. | Completed | The quickstart-lib recipe reached the source. |
| Which package did it install? | @nestjs/core 12.5.1 installed in 11.3 seconds. |
Completed | The recorded command selected the package from npm. |
| How large was the installed dependency directory? | node_modules occupied 17.5 MB. |
Recorded | This size belongs to the package-level attempt. |
| How many additional packages were installed? | 21 packages besides @nestjs/core. |
Recorded | The dependency-count step counted the additional packages. |
| Did the unedited README snippet run under tsx? | The 13-line snippet failed in 0.4 seconds with exit 1 and TransformError. |
Failed | The transformation step stopped execution. |
| What finding did the run save? | snippet-failed. |
Failure recorded | The saved finding names the README snippet failure and TransformError. |
| Did cleanup finish? | Teardown returned OK. | Completed | The teardown record reports success. |
The documented execution path is npm run start:dev in a Nest project. The Nest README says the CLI emits decorator metadata used by constructor injection by type and ValidationPipe. It separately says tools such as tsx omit that metadata and leave injected dependencies undefined. The observed error in this attempt was TransformError; the README's metadata explanation describes a tooling requirement, rather than a diagnosis of that error.
Our October 26, 2026 run exercised contributor checkout af957c9. We measured a successful installation, build and test suite in a sandbox configured with 3 CPUs, 8 GB RAM and image label lab-node:22. These figures describe the installed contributor workspace. Keeping that workspace separate from the November package-level attempt explains why their dependency counts and disk sizes differ.
| October contributor checkout | Our recorded result |
|---|---|
| npm install | Succeeded in 61 seconds; 1,260 dependencies recorded, 591 MB on disk |
| Build | Succeeded in 21 seconds |
| Vitest tests | Succeeded in 78 seconds; 4,940 passed, 0 failed of 4,940 |
| npm audit | 43 known vulnerabilities: 3 critical, 20 high, 17 moderate, 3 low |
| Repository scan | 2,601 files, approximately 194,531 source lines, 7.8 MB checked out |
| Layout signals | 2 CI workflow files, no Dockerfile, no tests directory, monorepo workspaces |
The repository scan found no directory named tests, while Vitest found and passed 4,940 tests. The directory result is therefore a layout observation alongside the suite result. Likewise, 591 MB is the installed contributor checkout's size. Application setup follows the packages and integrations selected for that application; the November recipe installed a smaller package set and exercised a different task.
Where people get stuck: dependencies cross module boundaries
Issue #363 describes a test failing during service construction because Nest could not resolve an injected database dependency. Even a trivial assertion required the testing module to construct the service first. The discussion shows why replacing a database dependency belongs in an early application exercise: the testing module needs the dependency requested by the service, including the appropriate injection token. Database testing discussion
| Symptom and source | Reported approach | Outcome in the discussion |
|---|---|---|
| Mongoose model or TypeORM repository missing from a testing module, #363 | Supply the dependency or a mock with the matching injection token | Commenters report success; the original reporter also describes continued difficulty. Issue #363 |
| A class-validator constraint receives an undefined service, #528 | Connect class-validator to Nest's selected module with useContainer and fallbackOnErrors |
A commenter reports that the selected-module approach works without the earlier errors. Issue #528 |
Injected REQUEST becomes undefined after upgrading to 9.3.1, #11002 |
davidzwa reverted Nest packages to 9.2.1 | The commenter reports that the problem disappeared. Issue #11002 |
| A user wants Winston to replace the internal logger, #247 | The maintainer suggests a custom exception filter for error handling | The reply addresses handling errors through a custom filter. Logger discussion |
The validator discussion exposes a container boundary rather than a missing service declaration alone. A commenter explains that connecting class-validator to Nest makes it use Nest's dependency injection; another reports success with the selected application module. For readers tracing an undefined dependency, the useful question is which container creates the object and whether that container can supply what its constructor requests. Validator container discussion
The REQUEST report is explicitly about an upgrade to 9.3.1. Davidzwa says reverting to 9.2.1 removed the problem and also describes difficulty reproducing it in CodeSandbox. Preserve those version details when using the report to investigate similar symptoms. They identify the circumstances the participant described and prevent a historical workaround from turning into a general recommendation for a current application. Version-specific REQUEST report
Kafka client selection divides the participants
Participants in #13223 disagree about replacing KafkaJS because they want different client capabilities. The author questions its maintenance, while maintainer Kamil Myśliwiec favors an additional transport strategy that would let users migrate gradually. Sirmonin asks to retain KafkaJS because partition reassignment matters to their application. Those positions make the required client operations a concrete starting point for selecting a transport. Kafka client discussion
Frct1 reports traffic of 2-3 messages per minute and says disabling the Kafka strategy used 10 times less CPU time and almost 3 times less memory. The same commenter says the strategy was disabled from 11pm until 1am, and that memory returned toward normal after about 12 hours while staying 50 MB higher. These are frct1's reported observations. They suggest including idle operation as well as message processing in an application's transport evaluation. Kafka resource report
Monitoring also appears as integration work in #967. Weeco describes writing a Prometheus module and service for each project and wanting to avoid that repetition. The current README separately advertises NestJS Observe and says its SDK takes an API key. Choose the monitoring route as part of application setup so the team knows which metrics, credentials and operational components it is introducing. Metrics discussion, Nest README
Security starts with the reported connection-authentication window
ChrisKatsaras reports that a WebSocket connection can receive events before authentication finishes in the handleConnection approach discussed in #882. Hwan-seok later says an await was missing from the example. The exchange gives private-event applications a specific behavior to examine: when the connection becomes eligible to receive events relative to the authentication result. WebSocket authentication discussion
Our October audit recorded 43 known vulnerabilities in the installed dependency tree, including 3 critical and 20 high findings. That creates a separate dependency-triage task: inspect the affected paths and relate them to the application packages and code paths being deployed. The socket-authentication discussion and the audit answer different security questions, so neither should substitute for examining the other during an application review.
Nest vs Express, Fastify, Hono and Next.js
Nest's README lists Express, Fastify and Node's own HTTP server as platforms, making the application framework and HTTP platform separate choices. Nest adds its module and dependency model above that choice. Express describes itself as minimalist and unopinionated, while Fastify emphasizes its plugin architecture. The practical comparison is how much shared application structure your team wants to adopt. Nest README, Express README, Fastify README
| Comparison | Supplied evidence | Decision rule |
|---|---|---|
| Nest vs Express | Express describes itself as minimalist and unopinionated; Nest supplies modules and dependency injection. | Keep Express when direct routing and existing conventions meet the team's needs. |
| Nest vs Fastify | Fastify emphasizes plugins; Nest's README describes moving from Fastify while keeping plugins. | Keep Fastify alone when you prefer to own application structure; consider Nest when shared conventions are the goal. |
| Nest vs Hono | Nest's official account compares minimal application size with Express, Fastify and Hono. Official minimal-app statement | Read the statement as the project's case for a small starting structure. |
| Nest vs HapiJS | joshwiens reports rewriting an existing HapiJS API in a few hours and expresses enthusiasm. HapiJS adoption account | Use the account to frame a small migration exercise around your own API. |
| Nest vs Next.js | Nest's README describes acting as a Next.js backend and moving route handlers gradually. | Decide whether a separate backend framework serves the application. |
The official Fastify migration statement says plugins can keep working and routes can move one at a time or together. That describes a gradual adoption route for teams already using Fastify. Start with a route whose dependencies represent the application, so the exercise includes the plugin interactions and service boundaries that motivated the migration. Official Fastify migration statement
The current README documents a single-file start
The README documents --minimal for a single-file application, and v12.5.1 adds root module metadata as an argument to NestFactory.create(). The example registers a controller through that metadata. The README directs users to move it into a @Module() class when the root module needs middleware or when generated code needs registration. That gives a specific answer to the objection that every Nest application needs extensive scaffolding immediately. Nest README, v12.5.1 release notes
The same README sends support questions to Discord and reserves repository issues for bug reports and feature requests. That distinction helps readers choose where to ask about a setup problem. For the first application, follow the CLI-generated project and its documented start command, then introduce the database, validation and transport integrations the application requires. This keeps the initial exercise tied to the project's stated execution path.
What the other reviews get wrong
The supplied hardware and film reviews concern different entities, rather than making claims about NestJS. NerdWallet reviews Google Nest home-security products, and The Hollywood Reporter reviews Sean Durkin's film The Nest. Their appearance beside an ambiguous search phrase explains why this page identifies nestjs/nest immediately. It supplies a backend-framework decision for readers who mean NestJS. Google Nest review record, The Nest film review record
The earlier published version of this page also objected to small applications on the basis of generated project structure. The supplied current README now explicitly documents a single-file start. The useful question is therefore whether the application benefits from Nest's conventions as it grows. File count at the beginning of a project is a weaker decision criterion than how the team intends to organize dependencies and service boundaries.
FAQ
Participants at ArchitectNow, Trellis and Kerberus report using NestJS for products and dashboards in the production discussion. The questions below cover those adoption accounts, the supplied comparison searches and the integration questions raised in issues. Their answers point to the relevant framework choice or reported approach so readers can return to the longer discussion when it affects their application. Production discussion
Who uses NestJS in production, and what have they built?
Nartc reports two ArchitectNow products, Trellis developers describe a product with an Angular frontend, and mariolenis describes Kerberus's Callcenter & PBX dashboard. RecuencoJones adds a backend retrieving GitHub metadata and CMS content for adidas.github.io. The use-case table preserves the outcomes each participant reported, including appreciation of shared language, TypeScript support and maintenance conventions. Production discussion
How does NestJS compare with Express?
Nest supplies modules and dependency injection and lists Express as a supported platform. Express describes itself as minimalist and unopinionated. Choose according to the application structure the team wants: direct routing with its own conventions, or Nest's shared framework model. The supplied README descriptions support that architectural comparison. Nest README, Express README
How does NestJS compare with Next.js?
Nest's README describes using Nest as the backend of a Next.js application and moving route handlers across one by one. Using both is therefore an explicit upstream option. A team considering that arrangement should identify what a separate backend contributes, such as the shared service conventions that motivated its interest in Nest. Nest README
Can a small application start with minimal NestJS structure?
Yes. The README documents --minimal for a single-file application and directs users to run the project with npm run start:dev. It also explains when root metadata should move into a module class. The documented small start lets a team evaluate Nest's programming model before building out the application's integrations. Nest README
Can I migrate a Fastify application to NestJS while keeping my plugins and moving routes gradually?
The official Nest account says a Fastify application can keep its plugins and move routes individually or together. Nest's README also lists migration from Fastify while keeping plugins. That is the project's stated route for adopting Nest's application structure while retaining Fastify as the HTTP platform. Official migration statement, Nest README
How can a beginner learn NestJS and progress to practical projects?
The README begins with the Nest CLI and links to the official guide. Follow its project creation and start commands, then add a route with the dependencies your project needs. This gives a beginner a documented starting path and a practical next task connected to the database or transport they intend to use. Nest README
Is NestJS planning to support a Kafka client other than KafkaJS?
Kamil Myśliwiec favors an additional transport strategy in #13223 so users can migrate gradually. Participants also debate which client capabilities matter, including partition reassignment. The discussion gives a team evaluating Kafka a requirements question to answer first: which client operations must its transport preserve? Kafka transport discussion
Why is an injected REQUEST undefined after upgrading to Nest 9.3.1?
Davidzwa reports that reverting from 9.3.1 to 9.2.1 removed the undefined REQUEST symptom. The same comment describes difficulty reproducing it in CodeSandbox. Those details identify the reported upgrade circumstances and workaround; readers investigating the issue should retain both version numbers when comparing the report with their application's symptoms. REQUEST injection discussion
How do I mock Mongoose models or TypeORM repositories when Nest cannot resolve test dependencies?
Commenters in #363 recommend supplying the real dependency or a mock under the token requested by the service. The thread includes reports of successful configuration alongside continued difficulty. Start by identifying the constructor dependency and the testing module registration that should supply it, which is the dependency boundary exposed by the reported failure. Database testing discussion
How do I inject Nest services into a custom class-validator constraint?
Commenters in #528 describe connecting class-validator to Nest's container, including a selected-module approach with fallbackOnErrors. One commenter reports that the selected-module variant works without the earlier errors. The explanation centres on which container creates the constraint and whether that container can resolve the service it needs. Validator integration discussion
How do I validate uniqueness across multiple schema fields using injected services?
A participant in #528 asks how to extend a single-field example to multiple fields and schemas. The earlier container discussion addresses receiving an injected service, which is one part of that request. The multi-field question concerns the validation rule itself, so connecting the containers and implementing the desired uniqueness check are separate tasks. Multi-field validation question
Can guards protect a WebSocket gateway's handleConnection method?
Issue #882 requests guard support for handleConnection. The supplied exchange discusses manual authentication and disconnection, followed by a report that events can arrive before authentication finishes and a reply about a missing await. For a private-event application, the concrete requirement is that event eligibility follow a successful authentication decision. WebSocket connection discussion
What we have not tested yet
Our evidence covers contributor checkout af957c9 and the failed tsx snippet attempt at 085f83a168e9, rather than a production application or a successful CLI rerun. The short error tail does not identify the cause of TransformError. The sandbox image labels do not establish actual Node.js or operating-system versions. The installed npm package was 12.5.1; the October suite belongs to its recorded commit rather than a test of that release tag.
The recorded work contains no request-throughput or latency benchmark, production load run, full Fastify migration, Kafka consumer workload, private WebSocket delivery test, or monitoring-product evaluation. Frct1's resource figures are a community report, not our independent measurement. The WebSocket exchange leaves the authentication-window remedy unresolved, including the effect of the later await correction. The Kafka discussion is open and supplies no completed client replacement or delivery commitment.
Historical issue examples do not establish current-version compatibility, a released fix for the 9.3.1 REQUEST report, a complete Winston logger replacement, default metrics in Nest core, or a demonstrated multi-field uniqueness implementation. The October audit lacks dependency paths for determining deployed exposure and remediation. Its passing suite and audit totals describe that installed workspace. No numerical product ratings are assigned from these observations.
The adoption accounts are participant reports rather than independent measurements of delivery speed, scalability or maintenance cost. The supplied Reddit and YouTube records concern other meanings of nest, while Bilibili supplies course listings without transcripts or learner outcomes. Search volume and worldwide demand are unknown. Rendered layout, accessibility, related links and recommendation modules also fall outside this text-and-evidence review. The next useful application result is a representative route with its database dependency replaced in a test and its intended authentication behavior exercised.


