Tracelytics, a European startup, was struggling. For six months, they attempted to rein in an infrastructure bill that was rising by 30% each quarter. Their observability platform processed over 80 million daily events from scattered microservices. The issue wasn't scale; it was Node.js. They began with an architecture based on Express and npm modules, which worked well initially, but became unsustainable in production. Workers consumed 400MB of RAM at rest, cold starts hit 3.5 seconds, and the team spent more time updating dependencies than innovating. In October 2025, Alexander Brandt, the CTO, took a radical step and decided to migrate the platform's core to Deno.
Five months later, Tracelytics doubled its managed traffic with half the instances. Their AWS bill dropped from €68K to €28K monthly, and the average API response time shrank from 340ms to 85ms. However, the real victory was in the architecture they could build once the runtime was no longer an issue. This is the story of how a European startup bet on Deno in production, gaining a two-year lead over competitors still tied to npm.
The Breaking Point: Node.js Became a Bottleneck
Despite its issues, Tracelytics doesn't hate Node.js. In fact, their founding team has backend JavaScript experience from companies like Datadog and New Relic. However, problems began when they grew from 5 beta clients to 40 paying clients, with monthly fees ranging from €2K to €15K. Though their initial stack seemed solid with Express for the REST API, Redis for caching, and PostgreSQL for persistence, everything changed in production.
The first symptom was latency. Enterprise clients expected p99 latencies under 200ms, but Tracelytics promised 150ms and couldn't deliver. Cold starts in Lambda were unpredictable: averaging 1.2 seconds, spiking to 4 seconds. Upon investigation, they found each Lambda dragged along a 280MB node_modules, full of unused dependencies. Attempts to mitigate this with tools like webpack and esbuild only reduced cold starts to 2.8 seconds, still unacceptable.
Curiously, in terms of memory, each instance consumed 400MB of RAM when idle, scaling to 850MB when processing events. They paid for 51GB of RAM but actually needed only 18GB. Security-wise, over six months, they had to patch 14 critical vulnerabilities in npm. Imagine running npm audit, reading the report, updating, testing, and hoping nothing broke—all in 4-6 hour weekly cycles. Brandt estimated they spent €12K annually just keeping npm updated.
Why Deno Was the Only Viable Option (and Not Bun or Rust)
Rewriting in Rust? That was an internal debate. Rust could have eliminated memory and performance issues, but Brandt dismissed it: only one of eight engineers had real Rust experience, making the time needed to rewrite 45K lines of TypeScript devastating. Bun, although promising, was immature in 2025 and without serious companies using it in enterprise production, it wasn't a viable option.
On the other hand, Deno offered something unique: full native TypeScript compatibility, default security, and a granular permissions model without sacrificing the JavaScript ecosystem. The key? Maintain team productivity (everyone wrote TypeScript), eliminate npm (import dependencies via URLs with explicit versioning), improve security (explicit permissions), and enhance performance (Deno uses Tokio and Rust internally).
The team conducted a two-week proof of concept, rewriting the ingestion service, the most critical component:
- Cold start: from 2.8s to 340ms (an 8x increase in speed)
- Idle memory: from 400MB to 110MB (3.6x more efficient)
- Throughput: from 12K to 31K events/sec
- Bundle size: from 45MB to 8MB
- External dependencies: from 140 npm packages to 4 remote modules
Brandt approved the complete migration in three months.
The Real Architecture: How They Migrated Without Breaking Production
Ensuring zero downtime was crucial. With 99.9% SLAs and contractual penalties, Tracelytics couldn't take risks. They opted for a hybrid strategy: keeping Node.js in production while building the new Deno infrastructure in parallel, migrating components one by one with feature flags and traffic splitting.
Phase 1: Ingestion Layer (weeks 1-4)
The first component migrated was the ingestion service. In Node.js they used Express, ajv, and kafkajs. In Deno, they switched to:
- Oak as middleware
- Zod for validations
- kafka-deno for Kafka without C++ dependencies
They deployed both versions in parallel, configured AWS ALB to send 10% of traffic to Deno, monitored, and scaled to 100% without incidents.
Phase 2: Query Engine (weeks 5-9)
In the second phase, they migrated the query engine, the service that allows GraphQL queries. The challenge was security. In Node, Apollo Server has implicit access to everything. In Deno, they used gql with explicit permissions, limiting access to mitigate vulnerabilities.
Phase 3: Background Workers (weeks 10-12)
Finally, they migrated the workers that process aggregations and alerts. In Node.js, they used BullMQ with Redis, but each worker consumed memory even without work. In Deno, they implemented a more efficient model, reducing consumption from 16GB to 4.8GB.
The Real Numbers: What Changed and What Didn't
After five months, Brandt shared some results:
Infrastructure:
- EC2 Instances: from 28 to 12
- Total memory: from 48GB to 18GB
- AWS bill: from €68K to €28K
Performance:
- API p99 latency: from 340ms to 85ms
- Average cold start: from 2.8s to 340ms
- Ingestion throughput: from 12K to 31K events/sec
Operations:
- Security incidents: from 14 to 0
- Maintenance time: from 6h/week to 30min
- Failed deployments: from 3 to 0
Curiously, what didn't change was the time for developing new features or the learning curve, as TypeScript remains TypeScript. The key was maintaining team productivity.
The Technical Decisions No One Documents
Three critical decisions not documented in any Deno tutorial were:
1. They Didn’t Completely Eliminate npm
They maintained a small auxiliary service in Node.js for specific libraries where Deno still lacked mature alternatives. This service communicates with the Deno core via gRPC. Solid pragmatism.
2. They Versioned Absolutely Everything
They created a centralized deps.ts file where all external dependencies are explicitly versioned. This ensures reproducible builds and eliminates risks.
3. They Built Their Own Internal Registry
They set up a private registry using Deno Deploy where they publish internal modules with semantic versioning. A smart move to maintain project structure.
The Invisible Lesson: The Runtime Determines Your Architecture
In closing, Brandt concluded: "We didn't migrate to Deno for performance, but because Node.js forced us to be defensive all the time." Every decision was tainted by the question: Is this dependency safe? Will it break in the next version? Deno allowed them to move fast without breaking things. The real gain was the freedom to focus on what matters: creating valuable features. Is your startup still stuck on Node.js? Maybe you're tied to a runtime that, while familiar, limits your ability to scale efficiently.