Rada architektury, czwarty kwartał. Zespół odpowiedzialny za nową platformę zamówień dla klientów B2B proponuje backend w Node.js z TypeScriptem. Argumenty brzmią rozsądnie: frontend i tak jest w React, ten sam zespół napisze obie strony, rekrutacja idzie szybciej, a prototyp powstał w trzy tygodnie. Architekt korporacyjny odpowiada, że wszystkie systemy transakcyjne w firmie stoją na Javie, że ma do dyspozycji dział utrzymania, który zna JVM od podszewki, i że nie zgodzi się na „kolejny stos technologiczny”. Dyskusja przenosi się na benchmarki: ktoś pokazuje wykres żądań na sekundę, ktoś inny link do artykułu, w którym Node.js „nie skaluje się”.
Obie strony mają częściowo rację i obie dyskutują o niewłaściwej rzeczy. Liczba żądań na sekundę w syntetycznym teście prawie nigdy nie jest tym, co decyduje o koszcie backendu w dużej firmie przez pięć lat. Decyduje to, jaki rodzaj pracy ten backend wykonuje, ile kosztuje utrzymanie jego zależności i jak często trzeba go będzie aktualizować, żeby pozostał wspierany.
Ten artykuł jest dla CTO i architektów, którzy muszą zdecydować, gdzie w ich krajobrazie systemów jest miejsce na Node.js. Teza, której bronimy, może się nie spodobać ani zwolennikom, ani przeciwnikom tej platformy: Node.js jest bardzo dobrym wyborem na warstwy brzegowe i integracyjne dużej firmy, ale rdzeń domenowy z ciężką logiką, obliczeniami i wieloletnim horyzontem utrzymania lepiej domyślnie zostawić na Javie lub .NET. Nie dlatego, że Node.js jest „wolny”, tylko dlatego, że jego model wykonania, ekosystem i kalendarz wydań przerzucają na organizację koszty, których benchmark nie pokazuje. Jeśli dopiero poznajesz platformę, zacznij od naszego wprowadzenia czym jest Node.js; tutaj zakładamy, że wiesz, czym jest i chcesz wiedzieć, gdzie go postawić.
Dlaczego pytanie „czy Node.js nadaje się do enterprise” jest źle postawione?
Bo „enterprise” nie jest jednym rodzajem systemu. Duża firma ma w swojej architekturze co najmniej kilka warstw o zupełnie innych wymaganiach: aplikacje kanałowe (portal klienta, aplikacja mobilna, panel partnera), warstwę API i integracji, która łączy je z systemami wewnętrznymi, rdzeń domenowy z regułami biznesowymi i transakcjami, przetwarzanie wsadowe i raportowe oraz platformę danych. Pytanie, czy jedna technologia „nadaje się do enterprise”, jest tak samo nieprecyzyjne jak pytanie, czy samochód dostawczy nadaje się do transportu. Do czego konkretnie?
Popularność Node.js nie podlega dyskusji. W ankiecie Stack Overflow Developer Survey 2025 Node.js wskazało 48,7% respondentów odpowiadających na pytanie o technologie webowe (49,1% wśród zawodowych programistów), wyraźnie więcej niż ASP.NET Core (19,7%) i Spring Boot (14,7%). JavaScript używa 66% ankietowanych, TypeScript 43,6%, Javę 29,4%, a C# 27,8%. Te liczby mówią jednak o tym, jak wielu ludzi zna technologię, a nie o tym, do jakiej roli w architekturze się ona nadaje. Ankieta obejmuje też frontendowców, którzy uruchamiają Node.js tylko jako narzędzie buildu.
Lepsze pytanie brzmi więc: dla której warstwy mojej architektury Node.js obniża całkowity koszt, a dla której go podnosi? Odpowiedź zależy od trzech czynników, które omówimy po kolei. Pierwszy to kształt obciążenia: czy usługa głównie czeka na sieć, czy głównie liczy. Drugi to koszt ekosystemu: ile zależności przyciąga typowa aplikacja i ile pracy wymaga ich kontrola. Trzeci to kalendarz: jak często platforma wymusza aktualizację i jak długo wspiera każdą wersję. Czwarty, mniej techniczny, to ludzie: kogo masz i kogo możesz zatrudnić.
Jak działa event loop i co z tego wynika dla obciążenia backendu?
Dokumentacja Node.js opisuje model wykonania w jednym zdaniu: w Node.js są dwa rodzaje wątków, jedna pętla zdarzeń (event loop, nazywana też wątkiem głównym) i pula k wątków roboczych (Worker Pool). Cały kod JavaScript aplikacji, czyli cała logika biznesowa, którą piszą programiści, wykonuje się na tym jednym wątku pętli zdarzeń. Pula wątków, realizowana przez bibliotekę libuv, obsługuje część operacji systemowych, takich jak dostęp do plików, część funkcji kryptograficznych i kompresja. Według dokumentacji libuv jej domyślny rozmiar to 4 wątki, można go zmienić zmienną środowiskową UV_THREADPOOL_SIZE, a górny limit wynosi 1024.
Jak taki proces obsługuje tysiące równoczesnych połączeń? Dzięki temu, że większość czasu typowej usługi webowej to czekanie: na odpowiedź bazy danych, na inną usługę po HTTP, na kolejkę wiadomości. W modelu Node.js żądanie, które czeka na bazę, nie zajmuje wątku. Kod rejestruje, co ma się stać po nadejściu odpowiedzi, i oddaje sterowanie pętli, która w tym czasie obsługuje inne żądania. Gdy odpowiedź przychodzi, pętla wywołuje zarejestrowany fragment kodu. Jeden proces może więc utrzymywać bardzo wiele otwartych połączeń przy niewielkim zużyciu pamięci, bo nie potrzebuje osobnego stosu wątku dla każdego z nich.
To jest prawdziwa przewaga i nie należy jej lekceważyć. W klasycznym modelu „jeden wątek systemowy na żądanie”, z którego przez lata korzystały serwery aplikacyjne w Javie, każde czekające żądanie trzyma wątek, a wątki systemowe są kosztowne. Usługa, która agreguje dane z pięciu innych usług i spędza 95% czasu na czekaniu, w Node.js zużywa ułamek zasobów potrzebnych w takim modelu.
Ale ta sama konstrukcja ma drugą stronę, którą dokumentacja Node.js formułuje bez owijania w bawełnę: „powinieneś upewnić się, że nigdy nie blokujesz pętli zdarzeń. Innymi słowy, każdy z twoich callbacków JavaScript powinien kończyć się szybko”. Skoro wszystkie żądania dzielą jeden wątek, to każda operacja, która zajmuje go dłużej, wstrzymuje obsługę wszystkich pozostałych klientów jednocześnie. W modelu wielowątkowym wolne żądanie spowalnia głównie siebie. W Node.js wolne żądanie spowalnia wszystkich.
Co się dzieje, gdy backend w Node.js dostaje pracę obliczeniową?
Problem nie polega na tym, że ktoś świadomie uruchomi na serwerze symulację Monte Carlo. Problem polega na tym, że praca obliczeniowa wkrada się do zwykłych usług po cichu. Dokumentacja Node.js wymienia kilka typowych źródeł i warto je znać, bo każde z nich występuje w normalnych systemach biznesowych.
Pierwsze to duże dokumenty JSON. JSON.parse i JSON.stringify mają złożoność liniową, ale dla dużych danych „mogą trwać zaskakująco długo”. W przykładzie z dokumentacji, dla napisu o rozmiarze 50 MB, JSON.stringify trwał około 0,7 sekundy, a JSON.parse około 1,3 sekundy. Przez ten czas żaden inny klient nie dostał odpowiedzi. Usługa, która raz dziennie przyjmuje duży eksport od partnera, może w tym momencie zamrozić API dla wszystkich użytkowników portalu.
Drugie to wyrażenia regularne. Dokumentacja ostrzega przed zagnieżdżonymi kwantyfikatorami w rodzaju (a+)*, które przy złośliwie przygotowanych danych wejściowych mają wykładniczy czas działania. To klasa podatności nazywana ReDoS: jeden spreparowany parametr w żądaniu potrafi zablokować proces. W Javie czy .NET taki regex też jest problemem, ale zajmuje jeden wątek z puli, a nie cały serwer.
Trzecie to synchroniczne wersje funkcji systemowych. Dokumentacja wprost mówi, że w serwerze nie należy używać m.in. crypto.pbkdf2Sync, zlib.inflateSync, zlib.deflateSync, synchronicznych funkcji modułu fs ani child_process.execSync. Programista, który hashuje hasła wersją synchroniczną, bo tak było w przykładzie, wprowadza blokadę, której nie widać na środowisku testowym z jednym użytkownikiem.
Czwarte, najtrudniejsze do wychwycenia, to biblioteki. Dokumentacja radzi: „jeśli wywołujesz API, które może robić coś kosztownego, sprawdź jego koszt”. Generowanie PDF, przetwarzanie obrazów, walidacja dużych schematów, mapowanie dużych struktur danych, szablonowanie raportów. Każda z tych operacji może być wykonana w zależności z npm, której kodu nikt w zespole nie czytał.
Co z tego wynika dla architekta? To, że w Node.js wydajność usługi jest własnością całego kodu, który wykonuje się na pętli, a nie tylko infrastruktury. Dodanie kolejnych instancji za load balancerem pomaga na liczbę równoczesnych użytkowników, ale nie pomaga na żądanie, które blokuje proces na sekundę, bo w tej sekundzie wszyscy klienci tej konkretnej instancji czekają. W systemie, gdzie logika biznesowa jest bogata i stale rośnie, utrzymanie dyscypliny „każdy callback kończy się szybko” wymaga przeglądów kodu, monitoringu opóźnień pętli zdarzeń i testów obciążeniowych z realistycznymi danymi. To jest koszt, który trzeba wpisać do budżetu, a nie wada, która dyskwalifikuje platformę.
Czy worker threads rozwiązują problem pracy CPU-bound?
Node.js od wersji 12 ma stabilny moduł worker_threads, który pozwala uruchamiać kod JavaScript w osobnych wątkach. Dokumentacja określa jego przeznaczenie jasno: wątki robocze „są przydatne do wykonywania intensywnych obliczeniowo operacji JavaScript. Niewiele pomagają przy pracy intensywnej wejściowo-wyjściowo”, bo wbudowane asynchroniczne I/O Node.js jest wydajniejsze, niż mogłyby być workery.
To jest więc narzędzie dokładnie na problem opisany w poprzedniej sekcji. Generowanie raportu, parsowanie dużego pliku czy kosztowna walidacja mogą trafić do puli workerów, a pętla zdarzeń pozostaje wolna dla żądań. Dokumentacja opisuje dwie strategie: partycjonowanie, czyli dzielenie obliczenia na małe kawałki, między którymi pętla obsługuje inne zdarzenia, oraz przeniesienie pracy do puli wątków roboczych. Ostrzega też przed rozwiązaniem pozornie prostym: nie należy tworzyć procesu potomnego dla każdego klienta, bo żądania mogą przychodzić szybciej, niż da się tworzyć procesy.
Dlaczego mimo to worker threads nie zmieniają naszej tezy? Z trzech powodów.
Pierwszy: wątki robocze w Node.js nie współdzielą zwykłych obiektów JavaScript. Dane przekazuje się przez wiadomości (kopiowane) albo przez wyspecjalizowane bufory współdzielone. Jeśli obliczenie potrzebuje dużego modelu domenowego, trzeba go przesłać albo odtworzyć w workerze. Przy obiektach o rozmiarze kilkudziesięciu megabajtów sama serializacja potrafi zjeść znaczną część zysku.
Drugi: pulą workerów trzeba zarządzać. Ile wątków? Co, gdy kolejka zadań rośnie szybciej, niż pula je przetwarza? Jak ograniczyć rozmiar wejścia, żeby jedno żądanie nie zajęło wszystkich workerów? Dokumentacja Node.js zaleca minimalizowanie zmienności czasu zadań i odrzucanie zbyt dużych danych wejściowych. To są decyzje projektowe, które w Javie czy .NET podejmuje się przy konfiguracji gotowych, dojrzałych mechanizmów, a w Node.js często przy pisaniu własnego kodu albo doborze biblioteki.
Trzeci, najważniejszy: jeśli obliczenia stanowią główną część pracy usługi, to pula workerów jest obejściem, a nie projektem. Usługa, która w 70% czasu liczy, a w 30% czeka, nie korzysta z najmocniejszej strony Node.js, czyli taniego czekania. Płaci natomiast za jego słabsze strony: wolniejszy niż w JVM czy CLR dostęp do wielordzeniowości, mniej dojrzałe narzędzia profilowania pod obciążeniem produkcyjnym, bardziej rozproszony ekosystem bibliotek numerycznych. W takim przypadku prostsze i tańsze w utrzymaniu jest wydzielenie obliczeń do osobnej usługi w technologii stworzonej do wielowątkowości, a Node.js zostawienie jako warstwy, która z tej usługi korzysta.
Praktyczna reguła, którą można zapisać w standardach architektonicznych: worker threads są dobre na sporadyczne, ograniczone obliczenia w usłudze, która poza tym głównie czeka. Nie są uzasadnieniem, żeby w Node.js budować usługę, której istotą jest liczenie.
Jak Java i .NET podchodzą do tego samego problemu współbieżności?
Argument „Node.js jest szybszy, bo nie blokuje wątków” był mocny dekadę temu, gdy porównywano go z serwerami aplikacyjnymi przydzielającymi wątek systemowy każdemu żądaniu. Dziś obie główne platformy korporacyjne mają odpowiedzi na ten sam problem i warto je znać, zanim użyje się go w dyskusji.
W Javie od wersji 21 (JEP 444) dostępne są wątki wirtualne. Dokumentacja Oracle opisuje je jako „lekkie wątki, które zmniejszają wysiłek pisania, utrzymywania i debugowania wysokoprzepustowych aplikacji współbieżnych”. Wątek wirtualny nie jest przywiązany do wątku systemowego. Gdy wykonuje blokującą operację wejścia-wyjścia, środowisko uruchomieniowe zawiesza go i zwalnia wątek systemowy dla innych. Programista pisze zwykły, sekwencyjny kod, który czyta się łatwiej niż łańcuchy asynchronicznych wywołań, a platforma zachowuje się podobnie do pętli zdarzeń przy czekaniu na I/O. Dokumentacja jest przy tym uczciwa co do ograniczeń: wątki wirtualne „nie są szybszymi wątkami” i istnieją, żeby zapewnić skalę (wyższą przepustowość), a nie szybkość, oraz nie są przeznaczone do długich operacji obliczeniowych. Te ostatnie Java nadal wykonuje na zwykłej puli wątków systemowych, na wielu rdzeniach jednocześnie, bez kopiowania danych między wątkami. O wyborze frameworka na JVM (Spring, Quarkus, Micronaut) piszemy osobno w przewodniku po frameworkach Java na backend.
W .NET model async/await istnieje od lat i jest wbudowany w bibliotekę standardową oraz ASP.NET Core. Asynchroniczne operacje I/O zwalniają wątek z puli na czas czekania, a obliczenia trafiają na pulę wątków, która domyślnie wykorzystuje wszystkie rdzenie. Programista ma w jednym procesie oba tryby pracy i nie musi wybierać architektury pod kątem tego, czy usługa liczy, czy czeka.
Co z tego wynika? Że przewaga Node.js w obsłudze wielu połączeń nie jest już unikatowa, natomiast jego ograniczenie przy pracy obliczeniowej pozostało. Java i .NET pozwalają w jednym procesie obsługiwać dużo równoczesnych żądań czekających na I/O i równolegle liczyć na wszystkich rdzeniach, ze współdzieloną pamięcią i dojrzałymi narzędziami diagnostycznymi. Node.js obsługuje pierwszy przypadek bardzo dobrze, drugi wymaga od zespołu dodatkowej pracy. To nie czyni Node.js gorszym wyborem dla usług, które tylko czekają. Czyni go natomiast słabszym wyborem dla usług, które robią jedno i drugie, a takie są zwykle systemy rdzeniowe.
Gdzie Node.js w dużej firmie sprawdza się najlepiej?
Skoro wiemy, jak działa model wykonania, łatwiej wskazać miejsca, w których jego zalety dominują nad kosztami. Jest ich kilka i w dużej firmie są to często warstwy o największej liczbie zmian, czyli tam, gdzie szybkość dostarczania ma największą wartość.
Backend for Frontend (BFF). Warstwa, która dla konkretnej aplikacji webowej lub mobilnej agreguje dane z kilku usług wewnętrznych, przycina je do potrzeb ekranu i obsługuje sesję użytkownika. Praca BFF to w przeważającej części czekanie na inne usługi i składanie odpowiedzi. Gdy frontend jest napisany w TypeScripcie, ten sam zespół może utrzymywać oba końce, współdzielić typy kontraktów i zmieniać je w jednym przeglądzie kodu. To jest uczciwy argument za Node.js, a nie moda.
Usługi integracyjne i adaptery. Połączenia z systemami partnerów, bramkami płatności, systemami kurierskimi, platformami marketingowymi. Dużo wywołań HTTP, dużo transformacji niewielkich dokumentów JSON, częste zmiany po stronie partnerów. Dostępność SDK w npm dla prawie każdej usługi SaaS skraca czas budowy. Warunek: duże paczki danych przetwarza się strumieniowo, a nie w całości w pamięci.
Komunikacja w czasie rzeczywistym. WebSockety, powiadomienia, czaty obsługi klienta, tablice statusów. Wiele długotrwałych połączeń, z których większość przez większość czasu nic nie robi. Dokładnie ten scenariusz, dla którego model pętli zdarzeń został zaprojektowany.
Renderowanie po stronie serwera i warstwa webowa. Jeśli firma używa frameworków frontendowych z renderowaniem na serwerze, serwer i tak musi uruchamiać JavaScript. Dokładanie do tego osobnej warstwy w innej technologii tylko po to, żeby „nie mieć Node.js na produkcji”, rzadko się opłaca.
Narzędzia wewnętrzne, prototypy i krótkożyjące usługi. Panele administracyjne, automatyzacje, usługi kampanijne, które mają żyć kilka miesięcy. Tu krótki czas startu projektu ma większą wartość niż wieloletnia stabilność ekosystemu.
Funkcje serverless. Na platformach funkcji krótki czas startu i niewielkie zużycie pamięci mają bezpośrednie przełożenie na koszt i opóźnienia. Node.js jest tam jednym z najczęściej wspieranych środowisk.
Wspólny mianownik: usługi, które dużo czekają, mało liczą, zmieniają się często i są blisko interfejsu użytkownika albo granicy z systemami zewnętrznymi. W klasycznym podziale architektury to warstwa brzegowa i integracyjna.
Kiedy lepiej wybrać Javę lub .NET?
Odwróćmy listę. Są role w architekturze, w których Node.js można zastosować, ale całkowity koszt będzie wyższy niż przy Javie lub .NET. Nie dlatego, że coś „nie zadziała”, tylko dlatego, że zespół będzie budował i utrzymywał rzeczy, które w tamtych ekosystemach są gotowe.
Rdzeń domenowy z bogatą logiką. Systemy rozliczeń, wycen, polis, kredytów, rezerwacji, gospodarki magazynowej. Złożone reguły, setki encji, transakcje obejmujące wiele tabel, wieloletni horyzont życia. Java i .NET mają tu dojrzałe narzędzia mapowania obiektowo-relacyjnego, zarządzania transakcjami, walidacji i projektowania domenowego, rozwijane przez dekady i stabilne między wersjami. W ekosystemie Node.js odpowiedniki istnieją, ale są bardziej rozproszone, częściej zmieniają API i częściej konkurują ze sobą, co przy dziesięcioletnim horyzoncie oznacza więcej migracji.
Przetwarzanie wsadowe i raportowe. Nocne naliczenia, uzgodnienia, generowanie zestawień, eksporty dla regulatora. Praca, która z natury jest obliczeniowa i musi wykorzystać wiele rdzeni. To obszar, w którym ograniczenia opisane w poprzednich sekcjach przestają być teorią.
Systemy o wysokich wymaganiach co do przewidywalności opóźnień. Gdy umowa SLA mierzy percentyl 99,9, a nie średnią, każde zablokowanie pętli zdarzeń jest widoczne w raporcie. Na JVM i CLR wolne żądanie nie wstrzymuje innych, a narzędzia do analizy zachowania pod obciążeniem są dojrzalsze.
Środowiska silnie zintegrowane z istniejącym ekosystemem korporacyjnym. Jeśli firma ma platformę opartą na Active Directory, SQL Server i Azure, .NET jest naturalnym wyborem ze względu na integrację i narzędzia. Jeśli ma rozbudowany krajobraz JVM, z wewnętrznymi bibliotekami, standardami bezpieczeństwa i zespołem utrzymania, dokładanie Node.js w rdzeniu oznacza drugi zestaw standardów, drugą ścieżkę aktualizacji i drugi zestaw kompetencji w dziale operacji. Opis platform znajdziesz w haśle .NET w naszym słowniku.
Systemy, w których audyt i zgodność dotyczą każdej linii kodu. W sektorach regulowanych trzeba umieć wskazać, skąd pochodzi każda biblioteka, kto ją utrzymuje i jak szybko łatane są podatności. Im mniej zależności, tym łatwiej. Ten punkt prowadzi do następnej sekcji, bo to właśnie on najczęściej przesądza o wyniku.
Ważne zastrzeżenie: to są domyślne decyzje, a nie zakazy. Firma, w której cały dział inżynierii pracuje w TypeScripcie i nie ma ani jednej osoby znającej JVM, może rozsądnie zbudować rdzeń w Node.js, jeśli świadomie przyjmie wyższy koszt dyscypliny. Odwrotna sytuacja też się zdarza. Decyzja wbrew domyślnej powinna jednak być zapisana z uzasadnieniem w rejestrze decyzji architektonicznych, a nie wynikać z tego, że prototyp już działał.
Ile naprawdę kosztuje ekosystem npm i ryzyko łańcucha dostaw?
Rejestr npm jest największym rejestrem pakietów na świecie i to jest jednocześnie największa siła i największy koszt Node.js w dużej firmie. Siła, bo prawie każdy problem ma gotową bibliotekę. Koszt, bo kultura małych pakietów sprawia, że typowa aplikacja przyciąga setki zależności przechodnich, których nikt w zespole nie wybrał świadomie. Każda z nich jest kodem, który wykonuje się z pełnymi uprawnieniami aplikacji, a często także w trakcie instalacji, na maszynie programisty i w systemie CI.
Rok 2025 pokazał, że to nie jest ryzyko teoretyczne. 23 września 2025 amerykańska agencja CISA wydała alert o „szeroko zakrojonym ataku na łańcuch dostaw” w ekosystemie npm. Samoreplikujący się robak nazwany Shai-Hulud skompromitował według CISA ponad 500 pakietów. Po uzyskaniu dostępu przeszukiwał środowisko w poszukiwaniu poświadczeń, w tym tokenów GitHub i kluczy API do AWS, Google Cloud i Azure, wysyłał je do atakującego, a następnie logował się do rejestru npm jako przejęty programista, wstrzykiwał kod do kolejnych jego pakietów i publikował zainfekowane wersje. Zalecenia CISA obejmowały przegląd plików package-lock.json i yarn.lock pod kątem zależności przechodnich, przypięcie wersji do wydań sprzed 16 września 2025, natychmiastową rotację poświadczeń programistów i uwierzytelnianie wieloskładnikowe odporne na phishing.
Odpowiedź po stronie rejestru przyszła szybko. 22 września 2025 GitHub, właściciel npm, ogłosił plan zmian: tokeny granularne z ograniczonym czasem życia (siedem dni, a dla tokenów z prawem publikacji krócej), obowiązkowe 2FA przy publikacji lokalnej bez możliwości obejścia, wycofanie klasycznych tokenów i 2FA opartego na kodach TOTP na rzecz FIDO oraz promowanie mechanizmu trusted publishing zamiast tokenów. To podnosi poprzeczkę dla atakujących, ale nie zdejmuje odpowiedzialności z organizacji, która z pakietów korzysta.
Dlaczego to argument w dyskusji Node.js kontra Java i .NET, skoro Maven Central i NuGet też są rejestrami publicznymi i też bywały atakowane? Bo w praktyce różni się skala. Biblioteka standardowa Javy i .NET pokrywa znacznie więcej typowych potrzeb (kolekcje, daty, HTTP, kryptografia, serializacja), a frameworki korporacyjne przynoszą duże, spójne zestawy modułów utrzymywane przez jedną organizację. W Node.js ta sama funkcjonalność jest częściej rozproszona na wiele małych pakietów od różnych autorów. Więcej autorów to więcej kont, które można przejąć, i więcej punktów, które trzeba monitorować. Nie mamy wiarygodnego, porównawczego źródła z liczbą zależności przechodnich dla typowych aplikacji na trzech platformach, więc nie podajemy liczb; kierunek łatwo jednak sprawdzić na własnym projekcie, licząc pozycje w pliku lock.
Co to oznacza w budżecie? Że Node.js w dużej firmie wymaga stałej funkcji zarządzania zależnościami, a nie jednorazowej konfiguracji skanera. Minimalny zestaw praktyk wygląda tak:
- Instalacja w CI wyłącznie z pliku lock (
npm cizamiastnpm install), z przeglądem każdej zmiany pliku lock w pull requeście jak zmiany kodu. - Prywatne repozytorium pakietów jako pośrednik między rejestrem publicznym a buildami, z możliwością zablokowania konkretnej wersji w całej firmie w kilka minut.
- Kontrola skryptów instalacyjnych. Skrypty
postinstallbyły wektorem wielu ataków. Menedżer pnpm pozwala jawnie wskazać pakiety, którym wolno uruchamiać skrypty budowania, a w npm można je wyłączyć flagą--ignore-scriptstam, gdzie nie są potrzebne. - Opóźnienie przyjmowania świeżych wersji. pnpm ma ustawienie
minimumReleaseAge, które według dokumentacji określa minimalny czas (w minutach) od publikacji wersji, zanim pnpm ją zainstaluje, właśnie po to, by „zmniejszyć ryzyko instalacji skompromitowanych lub wadliwych pakietów”. Większość złośliwych wersji jest wykrywana i usuwana w ciągu godzin lub dni od publikacji. - SBOM przy każdym buildzie i automatyczne dopasowanie do baz podatności. O tym, dlaczego wykaz komponentów staje się wymogiem, piszemy w artykule o SBOM w 2026 roku.
- Odporne na phishing MFA i krótkotrwałe tokeny dla każdego, kto publikuje pakiety wewnętrzne, oraz brak długotrwałych sekretów chmurowych na maszynach programistów i w zmiennych środowiskowych CI dostępnych dla kroków instalacji.
Warto też znać granice wbudowanych zabezpieczeń. Node.js ma od wersji 22.13 i 23.5 stabilny model uprawnień (flaga --permission), który ogranicza dostęp do systemu plików, sieci, procesów potomnych i wątków roboczych. Dokumentacja wprost zaznacza jednak, że ta funkcja „nie chroni przed złośliwym kodem”, bo Node.js ufa każdemu kodowi, który ma wykonać. To pas bezpieczeństwa przeciwko przypadkowym błędom zaufanego kodu, a nie piaskownica dla nieznanych zależności.
Żadna z tych praktyk nie jest trudna. Wszystkie razem wymagają jednak czasu kogoś, kto za nie odpowiada, i ten czas trzeba policzyć przy porównaniu platform.
Jak cykl wydań Node.js wpływa na plan utrzymania?
Drugim kosztem, którego nie widać w benchmarku, jest kalendarz. Każda platforma wymaga aktualizacji wersji głównej, żeby pozostać objęta poprawkami bezpieczeństwa. Różnią się tym, jak często.
Do Node.js 26 obowiązywał rytm, który wielu architektów zna: dwie wersje główne rocznie, parzyste w kwietniu, nieparzyste w październiku. Nieparzyste żyły sześć miesięcy, parzyste przechodziły w tryb LTS z łącznie 30 miesiącami wsparcia długoterminowego. Projekt Node.js zmienił ten model. Według repozytorium nodejs/Release, począwszy od Node.js 27 nowa linia wydawnicza jest wydzielana raz w roku, w październiku, przechodzi przez fazę Alpha przeznaczoną dla autorów bibliotek i potoków CI, następnie przez fazę Current, a potem każda linia zostaje promowana do LTS. Każda dostaje 30 miesięcy wsparcia długoterminowego, łącznie 36 miesięcy od pierwszego wydania Current.
Stan na połowę listopada 2026 wygląda tak: Node.js 26 (Lithium) jest Active LTS od 28 października 2026 i będzie wspierany do 30 kwietnia 2029. Node.js 24 (Krypton) przeszedł w tryb Maintenance LTS 20 października 2026, z końcem wsparcia 30 kwietnia 2028. Node.js 22 (Jod) jest w Maintenance LTS do 30 kwietnia 2027. Node.js 20 osiągnął koniec wsparcia 30 kwietnia 2026, więc system, który nadal na nim działa, od pół roku nie dostaje poprawek bezpieczeństwa. Node.js 27 jest w fazie Alpha od 28 października 2026, wersja Current jest planowana na 22 kwietnia 2027. Dokumentacja projektu zaleca, by aplikacje produkcyjne używały wyłącznie wydań Active LTS lub Maintenance LTS.
| Platforma | Rytm wersji głównych | Okno wsparcia wersji długoterminowej | Wersja LTS na listopad 2026 i koniec jej wsparcia |
|---|---|---|---|
| Node.js (do v26) | dwie wersje rocznie, LTS tylko parzyste | 30 miesięcy LTS | Node.js 26: do 30.04.2029 |
| Node.js (od v27) | jedna wersja rocznie, każda staje się LTS | 30 miesięcy LTS, 36 miesięcy łącznie | Node.js 27: Current od 22.04.2027 (plan) |
| .NET | jedna wersja co listopad, LTS parzyste | LTS 3 lata, STS 2 lata | .NET 10: do 14.11.2028 |
| Java (Oracle JDK) | wydanie co pół roku, LTS co dwa lata | Premier 5 lat, Extended 8 lat | Java 25: Premier do 30.09.2030, Extended do 30.09.2033 |
Źródła: repozytorium nodejs/Release i strona wydań nodejs.org, polityka wsparcia .NET na dotnet.microsoft.com, zestawienie wsparcia Oracle JDK na endoflife.date. Daty mogą się zmienić; projekt Node.js sam zaznacza, że harmonogram podlega zmianom.
Co z tego wynika? Na poziomie samych dat różnice nie są dramatyczne: wszystkie trzy platformy wymagają migracji wersji głównej mniej więcej co dwa–trzy lata, jeśli chcesz pozostać na wspieranej wersji z rozsądnym zapasem. Java w modelu Oracle daje najdłuższe okna, .NET najbardziej przewidywalny rytm (zawsze listopad, zawsze trzy lata dla LTS), a Node.js właśnie upraszcza swój kalendarz do jednej wersji rocznie.
Prawdziwa różnica leży gdzie indziej: w tym, ile pracy kosztuje każda migracja. Aktualizacja środowiska uruchomieniowego to zwykle mała część. Większa to aktualizacja zależności, które przestają wspierać starą wersję, i ich własnych zależności. W ekosystemie z setkami małych pakietów od różnych autorów każda migracja oznacza sprawdzenie, które z nich są nadal utrzymywane, które zmieniły API i które trzeba zastąpić. Na JVM i CLR większość tej pracy przypada na kilka dużych frameworków o przewidywalnych ścieżkach aktualizacji. Dla architekta oznacza to prostą zasadę: plan utrzymania usługi w Node.js musi zawierać coroczny przegląd zależności i migrację LTS jako zaplanowaną pracę, a nie projekt ratunkowy.
Czy TypeScript wystarcza, żeby Node.js był „językiem korporacyjnym”?
TypeScript zmienił pozycję Node.js w dużych firmach bardziej niż jakakolwiek zmiana w samym środowisku uruchomieniowym. Statyczne typy, sprawdzanie kontraktów w czasie kompilacji, refaktoryzacja wspierana przez edytor, czytelne interfejsy między modułami. Bez TypeScriptu dyskusja o Node.js w rdzeniu dużego systemu w ogóle by się nie toczyła. Szersze porównanie znajdziesz w artykule TypeScript czy JavaScript.
W ostatnich wersjach Node.js zrobił też ważny krok w stronę TypeScriptu. Według dokumentacji natywne usuwanie typów (type stripping) jest domyślnie włączone od Node.js 23.6 i 22.18, a od wersji 24.12 i 25.2 ma status stabilny. Oznacza to, że plik .ts można uruchomić bezpośrednio, bez osobnego kroku kompilacji. Warto jednak wiedzieć, co to dokładnie znaczy. Node.js tylko usuwa adnotacje typów. Dokumentacja wprost mówi, że „nie jest wykonywane sprawdzanie typów”, więc kompilator tsc nadal musi działać w CI. Nie są też obsługiwane konstrukcje, które wymagają generowania kodu JavaScript: enum, przestrzenie nazw z kodem wykonywalnym, właściwości parametrów konstruktora i dekoratory. To ostatnie ma znaczenie praktyczne, bo popularne frameworki backendowe w Node.js mocno opierają się na dekoratorach, więc takie projekty i tak potrzebują kroku kompilacji.
Najważniejsza uwaga jest jednak inna. Typy w TypeScripcie istnieją wyłącznie w czasie kompilacji. W czasie wykonania nie ma po nich śladu. Dane, które przychodzą z sieci, z kolejki, z bazy albo z pliku od partnera, nie są w żaden sposób sprawdzane przez system typów. Zadeklarowanie, że pole amount jest liczbą, nie powstrzyma partnera przed przysłaniem napisu. W Javie i .NET deserializacja do silnie typowanych klas wymusza zgodność typu w czasie wykonania; w TypeScripcie trzeba to zrobić jawnie, biblioteką walidacji schematów na każdej granicy systemu.
To nie jest argument przeciwko TypeScriptowi. To argument, że TypeScript daje Node.js ergonomię języka korporacyjnego w edytorze, ale nie daje mu gwarancji środowiska uruchomieniowego, do których przyzwyczajeni są architekci JVM i .NET. Zespół musi tę lukę zamknąć dyscypliną: walidacja na każdej granicy, generowanie typów ze schematów kontraktów (OpenAPI, JSON Schema), zakaz typu any w kodzie domenowym i ścisłe ustawienia kompilatora. W rdzeniu domenowym, gdzie liczba granic i typów rośnie latami, ta dyscyplina kosztuje więcej niż w cienkiej warstwie BFF.
Jak skład zespołu i rekrutacja zmieniają rachunek?
Najmocniejszy argument za Node.js w dużej firmie rzadko jest techniczny. Jest kadrowy. Jeśli frontend jest w TypeScripcie, to zespół, który zna jeden język, może pracować po obu stronach interfejsu, a liczba osób, które można zatrudnić, jest duża. Dane z ankiety Stack Overflow 2025 to potwierdzają: JavaScript i TypeScript należą do najczęściej używanych języków, a Node.js jest najpopularniejszą technologią webową w ankiecie.
Ten argument wymaga jednak dwóch korekt.
Pierwsza: znajomość języka nie jest znajomością backendu. Programista, który świetnie pisze komponenty React, nie musi znać izolacji transakcji, strategii blokad w bazie, idempotencji przy ponownych próbach, projektowania schematu ani zachowania pętli zdarzeń pod obciążeniem. Pula kandydatów „znających TypeScript” jest duża, pula kandydatów z doświadczeniem w projektowaniu backendu dużych systemów w Node.js jest dużo mniejsza. Przy rekrutacji i ocenie kandydatów warto więc sprawdzać właśnie te kompetencje, a nie samą znajomość składni i frameworka.
Druga: koszt specjalisty nie zależy istotnie od platformy. W cenniku ARDURA stawki dla roli Backend Developer na poziomie senior wynoszą 1440–2080 zł netto za dzień (8 godzin), czyli 180–260 zł za godzinę, niezależnie od tego, czy backend powstaje w Node.js, Javie czy .NET. Dla roli Full-Stack Developer na poziomie senior to 1520–2160 zł dziennie. Szczegółowe widełki dla tej platformy opisujemy w artykule o stawkach programistów Node.js. Różnica w budżecie bierze się więc nie ze stawek, tylko z liczby osób i z tego, ile czasu zespół spędza na pracy, której w innym ekosystemie by nie było: zarządzaniu zależnościami, walidacji granic, pilnowaniu pętli zdarzeń.
Jest też trzeci, często pomijany aspekt: koszt drugiej platformy. Duża firma, która ma dział operacji znający JVM, standardy bezpieczeństwa napisane pod Javę i wewnętrzne biblioteki do logowania, uwierzytelniania i monitoringu w Javie, po wprowadzeniu Node.js musi te standardy przepisać, a dział operacji nauczyć diagnozować nowe środowisko. Ten koszt ponosi się raz, ale jest realny, i często przewyższa oszczędność wynikającą z szybszej rekrutacji do jednego projektu. Działa to też w drugą stronę: firma, której cały dział inżynierii pracuje w TypeScripcie, płaci podobną cenę za wprowadzenie JVM.
Wniosek dla CTO: policz zespół, który utrzyma system przez pięć lat, a nie zespół, który zbuduje pierwszą wersję. Jeśli Node.js ma być drugą platformą w firmie, potrzebujesz co najmniej dwóch–trzech osób z doświadczeniem backendowym na tej platformie, które ustanowią standardy i będą przeglądać kod pozostałych. Jeśli brakuje ich w zespole, można je pozyskać na czas ustanawiania standardów w modelu body leasingu doświadczonych programistów backend, z gwarancją wymiany specjalisty w ciągu 5 dni roboczych i 30-dniowym okresem wypowiedzenia.
Jak podjąć decyzję: jaka macierz pomoże architektowi?
Wszystkie powyższe czynniki da się sprowadzić do kilku pytań, które warto zadać dla każdej usługi osobno, a nie dla całej architektury naraz. Poniższa macierz nie zastępuje analizy, ale porządkuje dyskusję na radzie architektury i wymusza nazwanie powodów.
| Pytanie o usługę | Wskazuje na Node.js | Wskazuje na Javę lub .NET |
|---|---|---|
| Jaki jest kształt obciążenia? | głównie czekanie na sieć i bazy, małe dokumenty | znaczna część czasu na obliczenia, duże dokumenty, praca wsadowa |
| Jak daleko jest od interfejsu użytkownika? | BFF, SSR, warstwa API dla konkretnej aplikacji | rdzeń domenowy, system rekordów |
| Jak złożony jest model domenowy? | kilkadziesiąt encji, proste reguły | setki encji, złożone transakcje, reguły regulacyjne |
| Jaki jest horyzont życia? | miesiące do kilku lat, częste zmiany | dziesięć lat i więcej, rzadkie zmiany kontraktów |
| Jakie są wymagania co do opóźnień? | średnia i percentyl 95 | percentyl 99,9 w umowie SLA |
| Kto utrzyma usługę? | zespół pracujący w TypeScripcie na froncie i backendzie | dział z kompetencjami JVM lub .NET i ich standardami |
| Jak rygorystyczny jest audyt zależności? | standardowy, z SBOM i skanerem | sektor regulowany, każda biblioteka do uzasadnienia |
| Czy firma ma już tę platformę? | tak, z ustalonymi standardami | Node.js byłby nową, drugą platformą w rdzeniu |
Jak jej używać? Dla każdej nowej usługi zespół odpowiada na osiem pytań i zapisuje odpowiedzi w rejestrze decyzji architektonicznych. Jeśli większość odpowiedzi wskazuje w jedną stronę, decyzja jest prosta. Jeśli wyniki są mieszane, to zwykle sygnał, że usługa łączy dwie role i warto ją podzielić: cienką warstwę brzegową w Node.js i rdzeń w Javie lub .NET, z jasnym kontraktem między nimi.
Dla istniejących systemów macierz pomaga w innym pytaniu: czy problem z usługą w Node.js wynika z platformy, czy z tego, że usługa wyrosła poza rolę, do której ją wybrano. Typowy objaw drugiego przypadku to BFF, który z czasem przejął logikę wycen, generowanie dokumentów i raporty, a zespół od miesięcy walczy z opóźnieniami. Przepisanie całości na Javę rzadko jest właściwą odpowiedzią. Częściej wystarczy wydzielić obliczeniową część do osobnej usługi, a warstwę brzegową zostawić tam, gdzie jest. Jeśli nie wiesz, w jakim stanie jest kod, zanim podejmiesz decyzję, warto zlecić niezależny audyt kodu; w ARDURA audyt kondycji kodu kosztuje od 18 000 zł i ma stały zakres.
Jakie błędy przy wyborze backendu powtarzają się najczęściej?
Kilka wzorców decyzyjnych prowadzi do kosztownych korekt niezależnie od tego, którą platformę ostatecznie wybrano. Warto je nazwać, bo łatwo je rozpoznać na etapie dyskusji.
Decyzja na podstawie prototypu. Prototyp powstał szybko w Node.js, więc produkcyjny system też powstanie w Node.js. Prototyp nie ma jednak setek encji, transakcji, wymogów audytu ani danych produkcyjnych. Szybkość budowy prototypu mówi o ergonomii platformy, a nie o koszcie jej utrzymania przez pięć lat.
Decyzja na podstawie benchmarku. Syntetyczny test „hello world” mierzy narzut frameworka, a nie zachowanie usługi z realną logiką. W systemach biznesowych czas odpowiedzi zdominowany jest przez bazę danych i inne usługi, a różnice między platformami w samym przetwarzaniu żądania są zwykle mniejsze niż wpływ jednego źle napisanego zapytania SQL.
Jedna platforma dla wszystkiego z zasady. „U nas wszystko jest w Javie” prowadzi do ciężkich warstw BFF budowanych przez zespoły, które wolałyby pisać w języku frontendu. „U nas wszystko jest w TypeScripcie” prowadzi do rdzeni domenowych, w których zespół buduje od zera mechanizmy dostępne w innych ekosystemach. Standaryzacja ma ogromną wartość, ale standard może mieć dwie platformy z jasno przypisanymi rolami.
Brak właściciela zależności. Wybór Node.js bez wyznaczenia osoby lub zespołu odpowiedzialnego za politykę pakietów, prywatne repozytorium i coroczną migrację LTS. Problem ujawnia się zwykle dopiero przy pierwszym poważnym incydencie w łańcuchu dostaw albo gdy wersja środowiska traci wsparcie.
Zapominanie o dziale operacji. Zespół wybiera platformę, a ludzie, którzy będą ją diagnozować o trzeciej w nocy, dowiadują się o tym przy pierwszym wdrożeniu. Monitorowanie opóźnień pętli zdarzeń, analiza zrzutów pamięci V8, profilowanie pod obciążeniem to inne umiejętności niż analiza zrzutów wątków JVM.
Jak wprowadzić Node.js do dużej firmy, żeby nie żałować tej decyzji?
Jeśli macierz wskazała, że Node.js jest właściwym wyborem dla części Twojej architektury, kilka decyzji na starcie zmniejsza koszt na lata.
Zapisz rolę platformy w standardach architektonicznych. Na przykład: „Node.js z TypeScriptem jest domyślną technologią dla warstw BFF, usług integracyjnych i komunikacji w czasie rzeczywistym. Dla rdzenia domenowego domyślną technologią jest Java lub .NET; odstępstwo wymaga zapisu w rejestrze decyzji”. Taka reguła oszczędza dziesiątek dyskusji przy każdym nowym projekcie.
Ustal jedną wersję LTS i kalendarz migracji. Wszystkie usługi na jednej linii LTS, migracja na kolejną w ciągu kilku miesięcy od jej przejścia do Active LTS, koniec migracji wyraźnie przed końcem wsparcia poprzedniej. Przy nowym, rocznym rytmie Node.js to oznacza jedną zaplanowaną migrację w roku zamiast nieregularnych akcji ratunkowych.
Zbuduj platformę zależności, zanim powstanie pierwsza usługa. Prywatne repozytorium, polityka skryptów instalacyjnych, opóźnienie świeżych wersji, SBOM w każdym buildzie, procedura blokowania wersji w całej firmie. Dodanie tego po fakcie do dziesięciu usług kosztuje wielokrotnie więcej.
Ustandaryzuj szkielet usługi. Jeden framework, jedna biblioteka walidacji, jedno podejście do logowania i metryk, w tym metryka opóźnienia pętli zdarzeń jako obowiązkowy element każdego dashboardu. Szablon repozytorium, który każdy nowy projekt kopiuje, robi więcej niż dokument ze standardami.
Wyznacz właściciela. Zespół platformowy albo przynajmniej jedna osoba z mandatem do decyzji o zależnościach i wersjach. Bez tego punkty powyżej zostaną dokumentem, którego nikt nie stosuje.
Testuj obciążeniowo z realistycznymi danymi. Szczególnie z dużymi dokumentami i złośliwymi danymi wejściowymi, bo to tam ujawniają się blokady pętli zdarzeń. Test na pustej bazie z małymi żądaniami nie powie nic o tym, co się stanie, gdy partner przyśle 50-megabajtowy eksport.
Jakie są kluczowe wnioski dla CTO i architekta?
Spór „Node.js czy Java” jest zwykle sporem o niewłaściwe pytanie. Node.js nie jest ani zabawką dla startupów, ani uniwersalnym następcą platform korporacyjnych. Jest bardzo dobrym narzędziem do określonej klasy pracy i kosztownym narzędziem do innej.
Zapamiętaj siedem rzeczy. Po pierwsze, decyduj dla każdej usługi osobno, a nie dla całej architektury. Po drugie, w Node.js cały kod JavaScript wykonuje się na jednym wątku pętli zdarzeń, więc każda dłuższa operacja wstrzymuje wszystkich klientów instancji; usługi, które głównie czekają, korzystają z tego modelu, usługi, które głównie liczą, za niego płacą. Po trzecie, worker threads są dobre na sporadyczne obliczenia, a nie uzasadnieniem dla usługi obliczeniowej w Node.js. Po czwarte, Java z wątkami wirtualnymi i .NET z async/await dogoniły Node.js w obsłudze wielu połączeń i zachowały przewagę przy obliczeniach. Po piąte, ekosystem npm wymaga stałej funkcji zarządzania zależnościami; atak Shai-Hulud z września 2025 pokazał, dlaczego. Po szóste, od Node.js 27 obowiązuje roczny rytm wydań z 36 miesiącami wsparcia, a koszt migracji zależy głównie od liczby zależności. Po siódme, TypeScript daje ergonomię, ale nie gwarancje w czasie wykonania, więc walidacja na granicach jest obowiązkowa.
Domyślny podział, który wynika z tych punktów, jest prosty: Node.js na warstwy brzegowe i integracyjne, Java lub .NET na rdzeń domenowy i przetwarzanie obliczeniowe, jasne kontrakty między nimi. Odstępstwa są dopuszczalne, ale powinny być świadomą decyzją z zapisanym uzasadnieniem.
Jeśli stoisz przed wyborem technologii dla nowej platformy albo zastanawiasz się, czy istniejąca usługa w Node.js wyrosła poza swoją rolę, zobacz, jak pracujemy przy projektowaniu i tworzeniu oprogramowania, albo umów rozmowę. Faza discovery trwa 1–2 tygodnie i kończy się architekturą z przypisaniem technologii do każdej warstwy, którą można przedstawić radzie architektury.