Observed Signal · May 24, 2026 · Benchmark · Source: DEV Community · Impact: 2/5 · Sentiment: Neutral
Benchmark: Node.js vs Bun vs Go HTTP Performance
A developer published a controlled benchmark comparing default HTTP servers in Node.js, Bun and Go across three environments: localhost, an encrypted Tailscale Wi‑Fi mesh, and DigitalOcean cloud droplets. Tests ran each runtime in Docker (single-core and multi-core configurations), serving a simple /json response. Results show Bun leading raw throughput in many cloud multi-core runs (53,446 RPS on 4 cores), Go demonstrating strong single-process, low-latency efficiency (37,617 RPS on 4 cores; optimized raw bytes), and Node.js requiring clustering to approach comparable throughput (31,025 RPS on 4 cores clustered) while showing higher CPU and outlier latency in some scenarios. The author highlights network bottlenecks (local Wi‑Fi adapter) and implementation details (reusePort, Zig event loop, pre-rendered raw bytes) as key factors behind observed differences.
Runtime and network-level performance benchmarks inform backend infrastructure choices and cost/performance trade-offs for high-concurrency services (relevant to backend engineering and ad‑serving stacks), but this is a single-developer benchmark rather than a major platform policy or product release.
MARKET SIGNALS
Track Docker Signals & Strategic Shifts
Polaris7 connects regulatory filings, primary sources, leadership changes, and M&A activity into structured intelligence. Set up your Polaris7 workspace to monitor relevant companies in your executive briefing.
- Verified primary sources
- Automated briefings
- Instant watchlist setup
Key Takeaways & Evidence Grounding
- Publication date (page metadata): 2026-05-24
- Cloud 4-core benchmark (30s): Bun cluster 53,446 RPS, Go 37,617 RPS, Node.js cluster 31,025 RPS
- Cloud single-core benchmark: Bun 25,444 RPS, Go 13,935 RPS, Node.js 11,705 RPS
- Tailscale/Wi‑Fi (4 cores) throughput/latency snapshot: Bun 12,519 RPS (avg latency 16.49 ms), Go 12,873 RPS (avg 15.69 ms), Node.js 7,954 RPS (avg 26.79 ms) with Node max outlier 864.53 ms
- Tests run inside Docker with resource caps (--cpus, -m), DigitalOcean shared droplets over a 10 Gbps data‑center backplane used for cloud runs; load generated via wrk in an attacker container
Connected Companies & Entities
Ontology Mapping & Concepts
Related Market Signals & Shifts
Recent verified developments and strategic activity across this market segment.
Bun outperforms Node for high-throughput metadata API
An engineer at ViralVidVault benchmarked Bun against Node.js for a read-heavy, stateless batch video metadata endpoint backed by SQLite in WAL mode. The tests (64 concurrent connections, median of five runs) showed Bun delivering roughly 14,800 rps versus Node's ~9,400 rps, with lower median and tail latencies and lower resident memory. Profiling showed SQLite reads were ~2ms, and most latency came from JSON serialization, HTTP framing, and GC in the JavaScript runtime. The author migrated the single hot, read-only metadata endpoint to Bun behind a canary while keeping stateful and write-path services on Node due to native module compatibility, observability, and long-run stability concerns under GDPR obligations.
Bun + Cosmic: Fastest JavaScript Stack for 2026
A developer tutorial and performance overview demonstrating a Bun v1.3 runtime combined with Cosmic (a CDN-backed headless CMS) as a high-performance full-stack for content-heavy JavaScript apps in 2026. The article highlights Bun's fast startup, package installation, native TypeScript support, and recent features (zero-config frontend, unified SQL API, built-in Redis and image APIs, HTTP/3). It notes Anthropic acquired Bun in December 2025 and that Vercel added native Bun runtime support in October 2025. Cosmic's REST API and JavaScript SDK provide cached CDN-backed content with typical cached responses under 100ms. The piece includes step-by-step setup instructions (bun init, bun add @cosmicjs/sdk, createBucketClient) and example Bun.serve server code to fetch and serve Cosmic content without additional frameworks.
Dart Backend: Great Syntax, Poor Cloud Runtime
A developer migrated an OAuth2 microservice from Node.js to Dart using an AI agent (Claude Code). The code migration was fast and flawless, but runtime behaviour under Kubernetes proved problematic: the Dart VM holds memory after peak loads (returning ~6% of peak RSS within five minutes) and delivered lower throughput and worse latency under CPU-throttling compared with Go and Node.js. Benchmarks across Go, Node.js, Dart, Bun, Deno and .NET (repo: github.com/klerick/go-vs-dart) show Dart's per-core efficiency and memory-return behaviour are the primary blockers for cloud-native backend use. The Dart VM team confirmed the memory retention is a design choice tuned for Flutter's UI goals. The author concludes that teams should validate a runtime hypothesis with simple benchmarks before using AI agents to port production services.
WATCHLIST & BRIEFINGS
Receive future signals for Docker & competitors in your briefing
Stay ahead of material M&A deals, leadership changes, account wins, and product rollouts. Polaris7 connects primary filings, company newsrooms, and trade reporting directly into your executive briefing.
- Regular primary-source checks
- Structured Watchlist briefings
- Preserves current context
Market Signal Monitoring
Follow affected companies in Polaris7 with regular source checks and structured Watchlist briefings.
Monitor Docker
Follow affected companies in Polaris7 with regular source checks and structured Watchlist briefings.
