Node.js on the backend in 2026: event loop and cluster topology

[Aior]

Node.js neden tercih ediyoruz, neden etmiyoruz?​

Node.js, AIOR'da real-time gerektiren projelerde varsayılan tercihimiz. WebSocket sunucusu, chat altyapısı, dashboard'ların canlı veri akışı ve hızlı prototip API'leri için elimizdeki en üretken yığın. Ancak her şey için doğru araç değil. Senkron iş ağır olan, CPU yoğun hesaplamalar yapan veya köklü ORM disipliniyle kurulmuş büyük domain modelleri olan projelerde Node.js seçimi pahalıya mal olur.

Event loop'u anlamayanı vurur​

2026'da hâlâ üretimde Node.js işleten ekiplerin yarısı event loop davranışını net bilmiyor. AIOR olarak en sık karşılaştığımız üretim sorunu uzun süren senkron iş — JSON parse'lerken bekleyen 100ms bile diğer istekleri eziyor. `clinic.js doctor`, `0x` flame graph, `--inspect` ile profil çıkarmak rutin alışkanlığımız olduğu için bu tür darboğazları erken yakalıyoruz.

Daha geniş hesaplama için `Worker Threads` doğru çözüm. PDF üretimi, görsel işleme, kriptografik imza gibi işler ana thread'i bloke etmemeli. AIOR projelerinde bu kalıbı standart kabul ediyoruz: ana thread sadece HTTP istek/yanıt akışı, ağır iş worker'lara.

Framework değil runtime seçimi​

Node.js'te framework tartışmasından önce runtime tartışması var. Bun ve Deno son iki yılda ekosistemde tutundu. Bizim AIOR perspektifimizden değerlendirme:

• Node.js — üretim için varsayılan seçim. Ekosistem en olgun, monitoring araçları en zengin, kurumsal destek en yaygın.
• Bun — geliştirme deneyimi son derece hızlı, dosya çalıştırma, paket yönetimi ve test runner tek pakette. Üretime almak için ekosistem olgunluğu hâlâ Node'un gerisinde.
• Deno — TypeScript native, güvenlik modeli (--allow-X) öğretici. Edge fonksiyonlar ve script çalıştırma için iyi; klasik backend için niş.

Express, Fastify, NestJS — hangisi nereye?​

• Express — küçük projeler, hızlı prototipler. Olgun ama performans pik değil.
• Fastify — performans odaklı kararlar için. Plugin ekosistemi sağlam, JSON schema validation native.
• NestJS — büyük kurumsal projeler, Angular benzeri yapısal mimariyi seven ekipler. TypeScript-native, dependency injection container'ı zengin.

AIOR'da NestJS'i müşteri panelleri ve ERP entegrasyonlarında sıkça kullanıyoruz; Fastify'ı yüksek throughput API'lerde tercih ediyoruz.

Bağımlılık yönetimi​

2026'da npm ekosistemi büyük ama dikkatli yönetilmesi gereken bir alan. AIOR projelerinde standart uygulamalarımız: `package-lock.json` her zaman commit edilir, `npm audit` haftalık çalışır, `npm ci` (npm install değil) production deploy'da kullanılır. Snyk veya Socket.dev gibi araçlarla bağımlılıkların güvenlik durumunu CI'da otomatik tarıyoruz.

Bir uyarı: minimalizm önemli. Yüzlerce bağımlılık taşıyan bir Node.js servisi her güncelleme zorluğunda yeni bir kırılma noktası demek. Standart yaklaşımımız: bir kütüphane eklemeden önce, "bunu 50 satır kendi koduyla yapabilir miyim?" sorusu.

Production'a almak​

PM2 hâlâ küçük-orta servislerde geçerli. Docker + Kubernetes orta-büyük ölçekte standart. Sistem kaynaklarını izlemek için Prometheus exporter standart eklediğimiz katman. AIOR olarak her Node.js servisinin yapılandırılmış JSON log üretmesini, request-id propagation taşımasını ve `/metrics` endpoint açmasını şart koşuyoruz.

Hata yönetimi ve geri dönüş kalıpları​

JavaScript'in async hata yönetimi tarihsel olarak en zayıf yanlardan biri. AIOR'da Node.js projelerinde standart kabul ettiğimiz pratik: tüm async fonksiyonlar try/catch ile sarılır; üst seviyede unhandled promise rejection için global handler tanımlanır; her hata Sentry'ye context ile (request-id, user-id, operation) gönderilir. `process.on('unhandledRejection')` tek başına yeterli değil; her async fonksiyonun açık hata kontratı olmalı.

Veritabanı katmanı​

Node.js projelerinde tercihimiz Prisma veya TypeORM. Prisma şema-driven, otomatik tip üretimi ve migration yönetimi güçlü. TypeORM daha geleneksel decorator-based, Java/.NET deneyimi olan ekiplere yakın. Üretimde her ikisinde de connection pooling Pgbouncer veya RDS Proxy gibi katmanla yönetilmeli — uygulama tarafı pool'a güvenilemez.

Sonuç​

Node.js 2026'da real-time, hafif backend ve hızlı geliştirme için hâlâ rakipsiz bir tercih. Event loop disiplinine sahip ekiplerle, doğru framework seçimi ve sıkı bağımlılık yönetimi ile çok ölçeklenir. Diğer dillerde olmayan bir avantajı var: aynı dil, aynı tip sistemi (TypeScript), aynı geliştirici ekibi backend ve frontend boyunca çalışabilir. Sizin Node.js operasyonunuzdaki en büyük dert ne — bağımlılık güvenliği mi, performans profili mi, yoksa team capability mi?

Why we pick Node.js, and why we don't​

Node.js is AIOR's default on projects that demand real-time. WebSocket servers, chat infrastructure, live data streams for dashboards, fast prototype APIs — it's the most productive stack we keep reaching for. But it isn't the right tool for everything. Sync-heavy workloads, CPU-bound computation, or large domain models built around mature ORM discipline make Node.js an expensive choice.

The event loop punishes the ignorant​

Half of teams running Node.js in 2026 still don't deeply understand event loop behaviour. The single most common production problem we see at AIOR is long synchronous work — even a 100ms JSON parse blocks every other request behind it. `clinic.js doctor`, `0x` flame graphs, and `--inspect` profiling are routine for us, so we catch these bottlenecks early.

For heavier compute, `Worker Threads` is the right answer. PDF generation, image processing, cryptographic signing — none of these should block the main thread. AIOR projects treat the pattern as standard: main thread is HTTP I/O only, heavy work goes to workers.

Runtime choice precedes framework choice​

Before the framework debate, there's a runtime debate. Bun and Deno have both stuck around since 2024. From AIOR's vantage:

• Node.js — production default. Ecosystem most mature, monitoring tooling richest, enterprise support most widespread.
• Bun — DX is genuinely fast; file run, package manager, and test runner in one package. Production ecosystem maturity still trails Node.
• Deno — TypeScript native, the security model (--allow-X) is pedagogically clean. Good for edge functions and scripting; niche for classic backend.

Express, Fastify, NestJS — where does each fit?​

• Express — small projects, fast prototypes. Mature but not a performance leader.
• Fastify — for performance-conscious decisions. Plugin ecosystem solid, JSON schema validation native.
• NestJS — large enterprise projects, teams comfortable with Angular-flavoured structural architecture. TypeScript native, rich DI container.

At AIOR, we use NestJS often for customer panels and ERP integrations; Fastify for high-throughput APIs.

Dependency management​

The npm ecosystem in 2026 is broad but must be managed carefully. AIOR standards: `package-lock.json` always committed, `npm audit` runs weekly, `npm ci` (not `npm install`) on production deploys. Snyk or Socket.dev for dependency security scanning in CI.

A warning on minimalism: a Node.js service carrying hundreds of dependencies introduces a new break point at every upgrade cycle. The question we ask before adding a library: "Can I do this in 50 lines of our own code?" Often the answer is yes.

Shipping to production​

PM2 is still valid for small-to-mid services. Docker + Kubernetes is standard at mid-to-large scale. A Prometheus exporter is the monitoring layer we always add. Every AIOR Node.js service emits structured JSON logs, propagates a request-id, and exposes a `/metrics` endpoint as standard.

Error handling and recovery patterns​

Async error handling has historically been one of JavaScript's weakest areas. AIOR's standard practice on Node.js: every async function wrapped in try/catch; a global handler for unhandled promise rejections at the top; every error shipped to Sentry with context (request-id, user-id, operation). `process.on('unhandledRejection')` alone isn't enough; each async function needs an explicit error contract.

The database layer​

Our pick on Node.js projects is Prisma or TypeORM. Prisma is schema-driven, with strong auto-generated types and migration management. TypeORM is more traditional decorator-based, closer to teams with Java/.NET background. In production, connection pooling for either should be handled by a layer like PgBouncer or RDS Proxy — the application-side pool can't be trusted on its own.

Bottom line​

Node.js in 2026 remains an unmatched choice for real-time, lightweight backend, and fast development. With teams that have event-loop discipline, the right framework choice, and tight dependency management, it scales surprisingly far. It has one advantage no other backend offers: the same language, the same type system (TypeScript), the same developer team can move across backend and frontend. What's the biggest pain in your Node.js operation — dependency security, perf profile, or team capability?