Architecture review board, fourth quarter. The team behind a new B2B ordering platform proposes a Node.js backend with TypeScript. The arguments sound reasonable: the frontend is React anyway, one team can write both sides, hiring is faster and the prototype took three weeks. The enterprise architect replies that every transactional system in the company runs on Java, that the operations group knows the JVM inside out, and that he will not sign off on “yet another stack”. The conversation drifts into benchmarks: someone shares a requests-per-second chart, someone else a blog post claiming Node.js “doesn’t scale”.
Both sides are partly right, and both are arguing about the wrong thing. Requests per second in a synthetic test is almost never what decides the five-year cost of an enterprise backend. What decides it is the kind of work the backend does, what it costs to keep its dependencies under control and how often it must be upgraded to stay supported.
This article is for CTOs and architects who need to decide where Node.js belongs in their system landscape. The thesis we defend may annoy both fans and critics of the platform: Node.js is an excellent choice for the edge and integration layers of a large organisation, but a domain core with heavy logic, computation and a long maintenance horizon should by default stay on Java or .NET. Not because Node.js is “slow”, but because its execution model, its ecosystem and its release calendar push costs onto the organisation that no benchmark shows. If you are new to the platform, start with our introduction to what Node.js is; here we assume you know what it is and want to know where to put it.
Why is “is Node.js enterprise-ready?” the wrong question?
Because “enterprise” is not one kind of system. A large organisation has at least several layers with very different requirements: channel applications (customer portal, mobile app, partner dashboard), an API and integration layer that connects them to internal systems, a domain core with business rules and transactions, batch and reporting workloads, and a data platform. Asking whether one technology is “enterprise-ready” is as vague as asking whether a van is suitable for transport. Transport of what?
Node.js popularity is not in question. In the Stack Overflow Developer Survey 2025, 48.7% of respondents who answered the web technologies question used Node.js (49.1% of professional developers), well ahead of ASP.NET Core (19.7%) and Spring Boot (14.7%). JavaScript is used by 66% of respondents, TypeScript by 43.6%, Java by 29.4% and C# by 27.8%. Those numbers describe how many people know a technology, not which architectural role it suits. The survey also counts frontend developers who run Node.js only as a build tool.
The better question is: for which layer of my architecture does Node.js lower total cost, and for which does it raise it? The answer depends on three factors, covered in turn below. First, the shape of the workload: does the service mostly wait on the network, or mostly compute? Second, the cost of the ecosystem: how many dependencies does a typical application pull in, and how much work does it take to control them? Third, the calendar: how often does the platform force an upgrade, and how long does it support each version? A fourth, less technical factor is people: whom you have and whom you can hire.
How does the event loop work, and what does it mean for backend workloads?
The Node.js documentation describes the execution model in one sentence: there are two types of threads, one event loop (also called the main thread) and a pool of k workers in a Worker Pool. All of the application’s JavaScript, meaning all the business logic your developers write, runs on that single event loop thread. The worker pool, implemented by the libuv library, handles some system operations such as file access, some cryptographic functions and compression. According to the libuv documentation its default size is 4 threads, it can be changed with the UV_THREADPOOL_SIZE environment variable, and the absolute maximum is 1,024.
How does one such process serve thousands of concurrent connections? Because most of a typical web service’s time is spent waiting: for the database, for another service over HTTP, for a message queue. In the Node.js model, a request waiting on the database does not occupy a thread. The code registers what should happen when the reply arrives and hands control back to the loop, which serves other requests in the meantime. When the reply arrives, the loop calls the registered code. A single process can hold a very large number of open connections with little memory, because it does not need a separate thread stack for each.
That is a real advantage and should not be dismissed. In the classic “one OS thread per request” model that Java application servers used for years, every waiting request holds a thread, and OS threads are expensive. A service that aggregates data from five other services and spends 95% of its time waiting uses a fraction of the resources in Node.js that it would need in that model.
The same design has a flip side, which the Node.js documentation states bluntly: “You should make sure you never block the Event Loop. In other words, each of your JavaScript callbacks should complete quickly.” Since every request shares one thread, any operation that holds it for longer stalls every other client at the same time. In a multi-threaded model, a slow request mostly slows itself. In Node.js, a slow request slows everyone.
What happens when a Node.js backend gets CPU-bound work?
The problem is not that someone will deliberately run a Monte Carlo simulation on the API server. The problem is that computation creeps into ordinary services quietly. The Node.js documentation lists several typical sources, and each of them shows up in normal business systems.
The first is large JSON documents. JSON.parse and JSON.stringify are linear in input size, but for large inputs they “can take surprisingly long”. In the documentation’s own example, with a 50 MB string, JSON.stringify took about 0.7 seconds and JSON.parse about 1.3 seconds. For that whole time no other client got a response. A service that accepts a large partner export once a day can freeze the API for every portal user at that moment.
The second is regular expressions. The documentation warns against nested quantifiers such as (a+)*, which have exponential running time on crafted input. This vulnerability class is known as ReDoS: one malicious request parameter can block the process. A bad regex is a problem in Java or .NET too, but there it ties up one pool thread, not the whole server.
The third is synchronous versions of system functions. The documentation says that in a server you should not use, among others, crypto.pbkdf2Sync, zlib.inflateSync, zlib.deflateSync, the synchronous fs APIs or child_process.execSync. A developer who hashes passwords with the synchronous variant because the tutorial did introduces a stall that never shows up in a single-user test environment.
The fourth, and the hardest to spot, is libraries. The documentation advises: “If you are calling an API that might do something expensive, double-check the cost.” PDF generation, image processing, large schema validation, mapping big data structures, report templating. Any of these can run inside an npm dependency whose code nobody on the team has read.
What does this mean for the architect? That in Node.js, service performance is a property of all the code running on the loop, not just of the infrastructure. Adding instances behind a load balancer helps with the number of concurrent users, but not with a request that blocks the process for a second, because during that second every client of that instance waits. In a system where business logic is rich and keeps growing, maintaining the “every callback completes quickly” discipline takes code review, event loop lag monitoring and load tests with realistic data. That is a cost to put in the budget, not a flaw that disqualifies the platform.
Do worker threads solve CPU-bound work?
Since version 12, Node.js has had a stable worker_threads module that runs JavaScript in separate threads. The documentation is clear about its purpose: workers “are useful for performing CPU-intensive JavaScript operations. They do not help much with I/O-intensive work”, because Node.js’s built-in asynchronous I/O is more efficient than workers can be.
So this is the tool for exactly the problem above. Report generation, parsing a large file or an expensive validation can go to a worker pool while the event loop stays free for requests. The documentation describes two strategies: partitioning, where a computation is split into small pieces with the loop serving other events in between, and offloading the work to a worker pool. It also warns against the deceptively simple option of spawning a child process per client, because requests can arrive faster than processes can be created.
Why do worker threads not change our thesis? For three reasons.
First, worker threads in Node.js do not share ordinary JavaScript objects. Data is passed as messages (copied) or through specialised shared buffers. If a computation needs a large domain model, it has to be sent to the worker or rebuilt there. With objects of tens of megabytes, serialisation alone can eat a large share of the gain.
Second, the pool has to be managed. How many threads? What happens when the task queue grows faster than the pool drains it? How do you bound input so one request cannot occupy every worker? The Node.js documentation recommends minimising variation in task times and rejecting inputs that are too long. These are design decisions that in Java or .NET you make by configuring mature, built-in mechanisms, and that in Node.js you often make by writing your own code or picking a library.
Third, and most important: if computation is the main job of a service, a worker pool is a workaround, not a design. A service that computes 70% of the time and waits 30% does not benefit from Node.js’s strongest feature, which is cheap waiting. It does pay for the weaker ones: less direct use of multiple cores than on the JVM or CLR, less mature profiling under production load, a more fragmented ecosystem of numeric libraries. In that case it is simpler and cheaper to maintain if the computation moves into a separate service built on a platform designed for multi-threading, with Node.js as the layer that calls it.
A practical rule you can write into architecture standards: worker threads are fine for occasional, bounded computation in a service that otherwise mostly waits. They are not a justification for building a service whose essence is computation in Node.js.
How do Java and .NET handle the same concurrency problem?
The argument that “Node.js is faster because it does not block threads” was strong a decade ago, when the comparison was with application servers that gave each request an OS thread. Today both major enterprise platforms have answers to the same problem, and it is worth knowing them before using that argument in a review meeting.
Java 21 (JEP 444) introduced virtual threads as a final feature. Oracle’s documentation describes them as “lightweight threads that reduce the effort of writing, maintaining, and debugging high-throughput concurrent applications.” A virtual thread is not tied to a specific OS thread. When it performs blocking I/O, the runtime suspends it and frees the OS thread for others. Developers write plain sequential code, which is easier to read than chains of asynchronous calls, and the platform behaves much like an event loop while waiting on I/O. The documentation is also honest about the limits: virtual threads “are not faster threads”, they exist “to provide scale (higher throughput), not speed”, and they are not intended for long-running CPU-intensive operations. Java still runs those on a regular pool of platform threads, across many cores at once, without copying data between threads. We cover framework choice on the JVM (Spring, Quarkus, Micronaut) separately in our guide to Java backend frameworks.
In .NET, the async/await model has existed for years and is built into the standard library and ASP.NET Core. Asynchronous I/O releases the pool thread while waiting, and computation goes to a thread pool that uses all cores by default. Developers get both modes in one process and do not have to choose an architecture based on whether a service computes or waits.
The upshot: Node.js’s advantage in handling many connections is no longer unique, while its limitation with computation remains. Java and .NET can serve many concurrent I/O-bound requests in one process and compute in parallel on every core, with shared memory and mature diagnostics. Node.js handles the first case very well; the second takes extra work from the team. That does not make Node.js a worse choice for services that only wait. It does make it a weaker choice for services that do both, and core systems usually do both.
Where does Node.js work best in a large organisation?
Once you understand the execution model, it is easier to pick the places where its strengths outweigh its costs. There are several, and in a large organisation they are often the layers that change most, where delivery speed is worth the most.
Backend for Frontend (BFF). The layer that, for a specific web or mobile app, aggregates data from several internal services, trims it to what the screen needs and handles the user session. Most of a BFF’s work is waiting on other services and assembling responses. When the frontend is in TypeScript, the same team can own both ends, share contract types and change them in a single code review. That is an honest argument for Node.js, not a fashion.
Integration services and adapters. Connections to partner systems, payment gateways, carriers, marketing platforms. Lots of HTTP calls, lots of small JSON transformations, frequent changes on the partner side. SDKs on npm for nearly every SaaS product shorten build time. The condition: large payloads are processed as streams, not loaded whole into memory.
Real-time communication. WebSockets, notifications, support chat, status boards. Many long-lived connections, most of which do nothing most of the time. Exactly the scenario the event loop was designed for.
Server-side rendering and the web tier. If you use frontend frameworks with server-side rendering, the server has to run JavaScript anyway. Adding a separate layer in another technology just to “not have Node.js in production” rarely pays off.
Internal tools, prototypes and short-lived services. Admin panels, automations, campaign services expected to live a few months. Here a fast project start is worth more than long-term ecosystem stability.
Serverless functions. On function platforms, fast start-up and a small memory footprint translate directly into cost and latency, and Node.js is one of the most widely supported runtimes there.
The common denominator: services that wait a lot, compute little, change often and sit close to the user interface or the boundary with external systems. In a classic layered view, that is the edge and integration tier.
When are Java or .NET the better choice?
Now reverse the list. There are architectural roles where Node.js can be used, but total cost will be higher than with Java or .NET. Not because something will “not work”, but because the team will build and maintain things that come ready-made in those ecosystems.
A domain core with rich logic. Billing, pricing, policy administration, lending, reservations, warehouse management. Complex rules, hundreds of entities, transactions spanning many tables, a lifetime measured in decades. Java and .NET have mature object-relational mapping, transaction management, validation and domain modelling tools here, developed over decades and stable across versions. Equivalents exist in the Node.js ecosystem, but they are more fragmented, change their APIs more often and compete with each other more, which over a ten-year horizon means more migrations.
Batch and reporting workloads. Overnight calculations, reconciliations, statements, regulatory exports. Work that is inherently computational and must use many cores. This is where the limits described above stop being theoretical.
Systems with strict latency predictability requirements. When the SLA measures the 99.9th percentile rather than the average, every event loop stall shows up in the report. On the JVM and CLR a slow request does not stall the others, and the tools for analysing behaviour under load are more mature.
Environments tightly integrated with an existing enterprise ecosystem. If the organisation runs on Active Directory, SQL Server and Azure, .NET is the natural choice for integration and tooling. If it has a large JVM estate with internal libraries, security standards and an operations team, adding Node.js to the core means a second set of standards, a second upgrade path and a second skill set in operations. The .NET entry in our glossary summarises the platform.
Systems where audit and compliance reach every line of code. In regulated sectors such as banking, insurance and healthcare, you must be able to say where every library came from, who maintains it and how fast vulnerabilities are patched. The fewer dependencies, the easier that is. This leads to the next section, because this point most often decides the outcome.
An important caveat: these are defaults, not bans. A company whose entire engineering organisation works in TypeScript, with nobody who knows the JVM, can reasonably build its core in Node.js if it consciously accepts the higher cost of discipline. The reverse also happens. A decision against the default should, however, be recorded with its rationale in an architecture decision record, not follow from the fact that the prototype already worked.
What do the npm ecosystem and its supply chain risk really cost?
The npm registry is the world’s largest package registry, and that is both the greatest strength and the greatest cost of Node.js in a large organisation. A strength, because almost every problem has a ready-made library. A cost, because the culture of small packages means a typical application pulls in hundreds of transitive dependencies that nobody on the team chose deliberately. Each is code that runs with the application’s full privileges, and often at install time too, on developer laptops and in CI.
2025 showed that this risk is not theoretical. On September 23, 2025, the US Cybersecurity and Infrastructure Security Agency (CISA) issued an alert about a “widespread supply chain compromise” in the npm ecosystem. A self-replicating worm known as Shai-Hulud had compromised, according to CISA, over 500 packages. Once inside, it searched the environment for credentials, including GitHub personal access tokens and API keys for AWS, Google Cloud and Azure, sent them to the attacker, then logged in to npm as the compromised developer, injected code into that developer’s other packages and published tainted versions. CISA’s recommendations included reviewing package-lock.json and yarn.lock files for affected packages including nested dependencies, pinning to known safe releases produced before September 16, 2025, immediately rotating developer credentials and requiring phishing-resistant multi-factor authentication.
The registry’s response came quickly. On September 22, 2025, GitHub, which owns npm, announced a plan: granular tokens with a limited lifetime (seven days, shorter for tokens with publishing rights), mandatory 2FA for local publishing with no bypass, deprecation of legacy classic tokens and of TOTP-based 2FA in favour of FIDO, and expansion of trusted publishing as the recommended alternative to tokens. That raises the bar for attackers, but it does not remove responsibility from the organisation consuming the packages.
Why is this an argument in a Node.js versus Java and .NET debate, when Maven Central and NuGet are public registries that have also been attacked? Because the scale differs in practice. The Java and .NET standard libraries cover far more everyday needs (collections, dates, HTTP, cryptography, serialisation), and enterprise frameworks bring large, coherent module sets maintained by a single organisation. In Node.js the same functionality is more often spread across many small packages from many authors. More authors means more accounts to compromise and more points to monitor. We have no reliable comparative source for transitive dependency counts in typical applications on the three platforms, so we give no figures; the direction is easy to check on your own project by counting entries in the lockfile.
What does that mean for the budget? That Node.js in a large organisation needs a standing dependency management function, not a one-off scanner configuration. The minimum set of practices:
- Install in CI only from the lockfile (
npm ciinstead ofnpm install), and review every lockfile change in a pull request like a code change. - A private package registry as a proxy between the public registry and your builds, so a specific version can be blocked across the company within minutes.
- Control of install scripts.
postinstallscripts have been the vector for many attacks. pnpm lets you explicitly list which packages may run build scripts, and npm can disable them with--ignore-scriptswhere they are not needed. - A delay before adopting fresh versions. pnpm’s
minimumReleaseAgesetting, according to its documentation, defines the minimum number of minutes after a version is published before pnpm will install it, specifically to “reduce the risk of installing compromised or defective packages”. Most malicious versions are detected and pulled within hours or days of publication. - An SBOM on every build, automatically matched against vulnerability databases. We explain why a software bill of materials is becoming a requirement in our article on SBOM in 2026.
- Phishing-resistant MFA and short-lived tokens for anyone publishing internal packages, and no long-lived cloud secrets on developer machines or in CI variables visible to install steps.
It also helps to know the limits of built-in protection. Since versions 22.13 and 23.5, Node.js has a stable permission model (the --permission flag) that restricts access to the file system, network, child processes and worker threads. The documentation states plainly, however, that this feature “does not protect against malicious code”, because Node.js trusts any code it is asked to run. It is a seat belt against accidental mistakes in trusted code, not a sandbox for unknown dependencies.
None of these practices is hard. Together, though, they need the time of someone who owns them, and that time belongs in any platform comparison.
How does the Node.js release cycle affect your maintenance plan?
The second cost that no benchmark shows is the calendar. Every platform needs major version upgrades to stay within security support. They differ in how often.
Up to Node.js 26, the rhythm many architects know applied: two major versions a year, even-numbered in April and odd-numbered in October. Odd-numbered lines lived six months; even-numbered lines moved to LTS with 30 months of long-term support. The Node.js project has changed that model. According to the nodejs/Release repository, starting with Node.js 27 a new release line is branched once a year, in October, goes through an Alpha phase aimed at library authors and CI pipelines, then a Current phase, and then every line is promoted to LTS. Each receives 30 months of long-term support, 36 months in total from the first Current release.
As of mid-November 2026: Node.js 26 (Lithium) has been Active LTS since October 28, 2026 and is supported until April 30, 2029. Node.js 24 (Krypton) entered Maintenance LTS on October 20, 2026, with end of life on April 30, 2028. Node.js 22 (Jod) is in Maintenance LTS until April 30, 2027. Node.js 20 reached end of life on April 30, 2026, so a system still running on it has received no security fixes for six months. Node.js 27 has been in Alpha since October 28, 2026, with the Current release planned for April 22, 2027. The project’s own guidance is that production applications should only use Active LTS or Maintenance LTS releases.
| Platform | Major release rhythm | Long-term support window | LTS line in November 2026 and its end of support |
|---|---|---|---|
| Node.js (up to v26) | two per year, LTS for even lines only | 30 months LTS | Node.js 26: until April 30, 2029 |
| Node.js (from v27) | one per year, every line becomes LTS | 30 months LTS, 36 months total | Node.js 27: Current from April 22, 2027 (planned) |
| .NET | one every November, LTS on even versions | LTS 3 years, STS 2 years | .NET 10: until November 14, 2028 |
| Java (Oracle JDK) | feature release every six months, LTS every two years | Premier 5 years, Extended 8 years | Java 25: Premier to September 30, 2030, Extended to September 30, 2033 |
Sources: the nodejs/Release repository and the nodejs.org releases page, the .NET support policy on dotnet.microsoft.com, the Oracle JDK support summary on endoflife.date. Dates can change; the Node.js project itself notes that its schedule is subject to change.
What follows? On dates alone the differences are not dramatic: all three platforms require a major version migration roughly every two to three years if you want to stay on a supported version with a reasonable margin. Java under Oracle’s model gives the longest windows, .NET the most predictable rhythm (always November, always three years for LTS), and Node.js is simplifying its calendar to one release a year.
The real difference lies elsewhere: in how much work each migration takes. Upgrading the runtime itself is usually the small part. The larger part is upgrading dependencies that drop support for the old version, and their own dependencies. In an ecosystem of hundreds of small packages from many authors, each migration means checking which are still maintained, which changed their API and which must be replaced. On the JVM and CLR most of that work falls on a few large frameworks with predictable upgrade paths. For the architect that gives a simple rule: a maintenance plan for a Node.js service must include an annual dependency review and LTS migration as scheduled work, not a rescue project.
Is TypeScript enough to make Node.js an “enterprise language”?
TypeScript has changed the position of Node.js in large organisations more than any change to the runtime itself. Static types, compile-time contract checks, editor-supported refactoring, clear interfaces between modules. Without TypeScript, the debate about Node.js in the core of a large system would not be happening at all. For the broader comparison, see our article on TypeScript versus JavaScript.
Recent Node.js versions have also taken an important step towards TypeScript. According to the documentation, native type stripping has been enabled by default since Node.js 23.6 and 22.18, and has been marked stable since 24.12 and 25.2. A .ts file can be run directly, with no separate compile step. It is worth knowing exactly what that means. Node.js only strips type annotations. The documentation says plainly that “no type checking is performed”, so tsc still has to run in CI. Constructs that require generating JavaScript are not supported either: enum, namespaces with runtime code, parameter properties and decorators. The last one matters in practice, because popular Node.js backend frameworks rely heavily on decorators, so those projects still need a build step.
The most important point is a different one, though. TypeScript types exist only at compile time. At runtime they leave no trace. Data arriving from the network, a queue, a database or a partner file is not checked by the type system in any way. Declaring that amount is a number will not stop a partner from sending a string. In Java and .NET, deserialising into strongly typed classes enforces type conformance at runtime; in TypeScript you must do it explicitly, with a schema validation library at every system boundary.
That is not an argument against TypeScript. It is an argument that TypeScript gives Node.js the ergonomics of an enterprise language in the editor, but not the runtime guarantees JVM and .NET architects are used to. The team has to close that gap with discipline: validation at every boundary, types generated from contract schemas (OpenAPI, JSON Schema), no any in domain code and strict compiler settings. In a domain core, where the number of boundaries and types grows for years, that discipline costs more than in a thin BFF.
How do team composition and hiring change the equation?
The strongest argument for Node.js in a large organisation is rarely technical. It is about people. If the frontend is in TypeScript, a team that knows one language can work on both sides of the interface, and the hiring pool is large. The Stack Overflow 2025 data supports this: JavaScript and TypeScript are among the most used languages, and Node.js is the most widely used web technology in the survey.
That argument needs two corrections.
First, knowing the language is not knowing the backend. A developer who writes excellent React components need not understand transaction isolation, database locking strategies, idempotency under retries, schema design or event loop behaviour under load. The pool of candidates who “know TypeScript” is large; the pool with experience designing backends for large systems in Node.js is much smaller. Those are the skills to test for in interviews, rather than syntax and framework familiarity alone.
Second, a specialist’s cost does not depend much on the platform. On the ARDURA pricing page, a senior Backend Developer is EUR 335–485 net per day (8 hours), whether the backend is built in Node.js, Java or .NET; a senior Full-Stack Developer is EUR 355–500 per day. We break down rates for this platform in our article on Node.js developer rates in Poland. The budget difference therefore comes not from rates but from headcount and from how much time the team spends on work that another ecosystem would not require: dependency management, boundary validation, guarding the event loop.
There is a third, often overlooked aspect: the cost of a second platform. A large organisation whose operations team knows the JVM, whose security standards are written for Java and whose internal libraries for logging, authentication and monitoring are in Java has to rewrite those standards and teach operations to diagnose a new runtime when it introduces Node.js. That is a one-off cost, but a real one, and it often exceeds the savings from faster hiring for one project. It cuts both ways: a company whose entire engineering team works in TypeScript pays a similar price to bring in the JVM.
The takeaway for the CTO: cost out the team that will maintain the system for five years, not the team that will build version one. If Node.js is to be a second platform in the company, you need at least two or three people with backend experience on it to set the standards and review everyone else’s code. If you do not have them, you can bring them in for the standard-setting period through staff augmentation with senior backend engineers, with specialist replacement within 5 business days and a 30-day notice period.
How should the decision be made, and what matrix helps the architect?
All of the factors above reduce to a handful of questions worth asking for each service separately, not for the whole architecture at once. The matrix below does not replace analysis, but it structures the review board discussion and forces people to name their reasons.
| Question about the service | Points to Node.js | Points to Java or .NET |
|---|---|---|
| What is the workload shape? | mostly waiting on network and databases, small documents | substantial computation, large documents, batch work |
| How close is it to the user interface? | BFF, SSR, API layer for a specific app | domain core, system of record |
| How complex is the domain model? | dozens of entities, simple rules | hundreds of entities, complex transactions, regulatory rules |
| What is its expected lifetime? | months to a few years, frequent change | ten years or more, rare contract changes |
| What are the latency requirements? | average and 95th percentile | 99.9th percentile in the SLA |
| Who will maintain it? | a team working in TypeScript across frontend and backend | a group with JVM or .NET skills and standards |
| How strict is the dependency audit? | standard, with SBOM and a scanner | regulated sector, every library must be justified |
| Does the company already run this platform? | yes, with established standards | Node.js would be a new, second platform in the core |
How to use it: for every new service the team answers the eight questions and records the answers in an architecture decision record. If most answers point one way, the decision is easy. If they are mixed, that usually signals the service combines two roles and should be split: a thin edge layer in Node.js and a core in Java or .NET, with a clear contract between them.
For existing systems the matrix helps with a different question: is the problem with a Node.js service caused by the platform, or by the service having outgrown the role it was chosen for? A typical symptom of the latter is a BFF that over time absorbed pricing logic, document generation and reporting, with the team fighting latency for months. Rewriting everything in Java is rarely the right answer. More often it is enough to extract the computational part into a separate service and leave the edge layer where it is. If you do not know the condition of the code before deciding, consider an independent technical due diligence; at ARDURA the Code Health Audit starts from EUR 4,500 and has a fixed scope.
Which backend selection mistakes come up most often?
A few decision patterns lead to costly corrections regardless of which platform is chosen in the end. They are worth naming, because they are easy to recognise while the discussion is still happening.
Deciding on the basis of a prototype. The prototype was quick to build in Node.js, so the production system will be built in Node.js too. But the prototype had no hundreds of entities, transactions, audit requirements or production data. Prototype speed tells you about the platform’s ergonomics, not about its five-year maintenance cost.
Deciding on the basis of a benchmark. A synthetic “hello world” test measures framework overhead, not the behaviour of a service with real logic. In business systems, response time is dominated by the database and other services, and the differences between platforms in request handling itself are usually smaller than the effect of a single badly written SQL query.
One platform for everything on principle. “Everything here is Java” leads to heavy BFF layers built by teams who would rather write in the frontend’s language. “Everything here is TypeScript” leads to domain cores where the team builds from scratch mechanisms that other ecosystems provide. Standardisation has great value, but a standard can include two platforms with clearly assigned roles.
No owner for dependencies. Choosing Node.js without naming a person or team responsible for package policy, the private registry and the annual LTS migration. The problem usually surfaces only at the first serious supply chain incident, or when the runtime version loses support.
Forgetting operations. The team picks a platform, and the people who will diagnose it at 3 a.m. find out at the first deployment. Monitoring event loop lag, analysing V8 heap snapshots and profiling under load are different skills from reading JVM thread dumps.
How do you introduce Node.js to a large organisation without regretting it?
If the matrix shows that Node.js is the right choice for part of your architecture, a few decisions at the start reduce cost for years.
Write the platform’s role into your architecture standards. For example: “Node.js with TypeScript is the default technology for BFF layers, integration services and real-time communication. Java or .NET is the default for the domain core; any exception requires an architecture decision record.” A rule like that saves dozens of discussions on every new project.
Agree one LTS line and a migration calendar. All services on one LTS line, migration to the next within a few months of it reaching Active LTS, and migration completed well before the previous line’s end of life. With Node.js’s new annual rhythm, that means one planned migration a year instead of irregular rescue efforts.
Build the dependency platform before the first service ships. Private registry, install script policy, a delay for fresh versions, an SBOM on every build, a procedure for blocking a version company-wide. Retrofitting all of that to ten services costs many times more.
Standardise the service skeleton. One framework, one validation library, one approach to logging and metrics, including event loop lag as a mandatory panel on every dashboard. A repository template that every new project copies does more than a standards document.
Name an owner. A platform team, or at least one person with a mandate to decide on dependencies and versions. Without that, the points above stay a document nobody follows.
Load test with realistic data. Especially with large documents and malicious input, because that is where event loop stalls appear. A test against an empty database with small requests tells you nothing about what happens when a partner sends a 50 MB export.
What are the key takeaways for the CTO and the architect?
The Node.js versus Java argument is usually an argument about the wrong question. Node.js is neither a toy for startups nor a universal successor to enterprise platforms. It is an excellent tool for one class of work and an expensive tool for another.
Remember seven things. First, decide per service, not for the whole architecture. Second, in Node.js all JavaScript runs on a single event loop thread, so any long operation stalls every client of that instance; services that mostly wait benefit from this model, services that mostly compute pay for it. Third, worker threads are fine for occasional computation, not a justification for a compute-heavy service in Node.js. Fourth, Java with virtual threads and .NET with async/await have caught up with Node.js on handling many connections and kept their advantage on computation. Fifth, the npm ecosystem needs a standing dependency management function; the Shai-Hulud attack of September 2025 showed why. Sixth, from Node.js 27 the release rhythm is annual with 36 months of support, and migration cost depends mostly on how many dependencies you carry. Seventh, TypeScript gives you ergonomics but no runtime guarantees, so validation at every boundary is mandatory.
The default split that follows is simple: Node.js for the edge and integration layers, Java or .NET for the domain core and compute-heavy processing, with clear contracts between them. Exceptions are acceptable, but they should be deliberate decisions with a recorded rationale.
If you are choosing technology for a new platform, or wondering whether an existing Node.js service has outgrown its role, see how we approach software design and development, or book a call. Discovery takes one to two weeks and ends with an architecture that assigns a technology to each layer, ready to take to your architecture review board.