NodeTLV '25

TypeScript! ESLint! Biome! Oh my! So many tools exist that we can choose from as modern developers. Do you ever feel like you're getting lost in a sea of GitHub README.mds and configuration file messes?

Let's talk about the state of tooling for TypeScript developers in 2025. What are the tools that many developers are finding helpful? How are those tools changing over time to be more helpful (and less annoying to configure)? Why do we even care about tooling when we have TypeScript!?

All those questions and more will be answered. We'll cover:
* The state of common tooling: linters, TypeScript, their integrations together (hello, Rust!)
* Some of the great benefits of aggressive static analysis (hello, plugins!)
* Miscellaneous other tools such as Knip and TypeChat (hello, AI!)
* High-level trends for tooling

After this talk, you'll not just be prepared to configure your linter and type checker - you'll appreciate why so many developers are excited for that task in the first place.

Add to Calendar

Achieving high performance in data-driven applications can be challenging—but it’s possible! In this talk, we’ll explore how we achieved a 10x improvement by transitioning to ClickHouse. You’ll learn about the database’s unique features, our approach to schema design, and the technical hurdles we overcame during integration. Perfect for developers and engineers looking to supercharge their apps with minimal overhead

Add to Calendar

JavaScript uses Garbage Collection (GC) for memory management. As a result, many developers that use JavaScript based systems, such as NodeJS, assume that they’re free of memory issues. Unfortunately this is incorrect, and many NodeJS-based services suffer from memory management problems such as leaks and excessive GC CPU cost. But finding, understanding, and resolving memory issues can be very challenging, because a problem in any part of the application impacts the application as a whole. Also, they may only manifest under load, in production environments. In this session I will explain how to find and fix such issues using the heap dump feature that is built into NodeJS. And I will show how to use the DevTools memory panel to analyze such dumps.

Add to Calendar

As Web developers we spend most of our days working with HTTP and the application layer. We know that our data gets transported over TCP but we rarely get to roll up our sleeves and write raw TCP code ourselves. In this talk we will examine use-cases where using TCP\UDP directly really shines, and how to implement them using Node.js and the 'net' module. We'll demonstrate how to bypass firewalls by creating outbound connections (like ngrok does). We'll see how to allow persistent bidirectional communication (like in the case of WebSockets). We'll gain a better understand how of SSH and VPNs work by creating a secure tunnel that encrypts its traffic. Of course we won't forget about the other major transport layer protocol- UDP, and we'll see why it's ideal for low-latency communication (as in DNS lookups and NTP time synchronization). By the end of this talk, you’ll know when TCP\UDP is the right tool for the job, and most importantly, how to implement it in code!

Add to Calendar

Reactive programming introduces a structured approach to building responsive and resilient systems, making it particularly well-suited for handling modern, event-driven application workloads.

This talk will explore how Node.js developers can implement reactive patterns to improve the performance and scalability of their applications.

Topics will include managing backpressure, efficiently handling high-concurrency data streams, and implementing non-blocking operations using tools like Node.js streams.

Through practical examples and comparisons with traditional async methods, participants will gain a clear understanding of how reactive programming can be applied to real-world scenarios in Node.js environments.

Add to Calendar

Large, legacy codebases often suffer from tangled dependencies, lack of modular boundaries, and monolithic "barrel" files that bundle together many modules. This makes the codebase difficult to understand, modify, and scale. In this talk, we'll explore strategies for "untangling the barrel" and simplifying a complex codebase to prepare it for migration to a monorepo architecture.
We'll cover techniques for
- Analyzing your code for cyclic dependencies
- Tools to help refactoring the code
- Establishing coding guidelines and automation to control codebase complexity going forward

Add to Calendar

OpenTelemetry is the 2nd most popular CNCF project, and for good reason: It's been going *huge*, disrupting how observability is done. Let's dive into it - what is observability, OpenTelemetry, how the Node.js sensor is implemented, and where should you watch your step.

We'll cover the basics, dive into real-world usage, and then go into the implementation itself.

You'll learn some practical tips on

Add to Calendar

Developers have gone full-steam from traditional programming to AI code assistants and vibe coding but what would you know when Claude 3.7 suggests vulnerable code in your Mongoose model hooks? Would you spot an insecure Fastify route middleware code that ChatGPT generated? Real stories, real risks. Even more so, where does it leave application security when risks of LLMs are weaponized against you and your AI applications are manipulated through prompt engineering to bypass security controls?

In a series of real-world application hacking demos I’ll demonstrate how developers mistakenly trust LLMs for generative AI code assistants that introduce insecure code and result in vulnerable applications that attackers easily exploit against you. We don’t stop here. We’ll apply adversarial attacks on neural networks in the form of invisible prompt injection payloads to compromise LLMs integrated into AI application workflows and weaponize them for SQL injection and other business logic bypass.

Join me in this session where you’ll learn how security vulnerabilities that impact Node.js application servers such as path traversal, prototype pollution, sql injection and other AI security risks are impacting LLMs and how to leverage AI security guardrails to secure GenAI code.

Add to Calendar

Ahoy, mateys! Imagine a crew of tech-savvy pirates who discover a hidden treasure but don’t trust each other enough to guard it alone. Instead of a single key, they devise a way to split the secret into multiple pieces—requiring a group effort to unlock it.

This talk will dive into Shamir's Secret Sharing (SSS), a cryptographic technique that enables secure, decentralized encryption. We’ll explore why traditional encryption isn’t always enough, how SSS ensures secrets are only revealed when enough participants collaborate, and how to implement it in Node.js.

With a blend of storytelling and live coding, we’ll see how pirates (and developers) can securely share secrets without putting all their trust in a single person.

Add to Calendar

Ever had too many people show up to your party and realize your tiny TLV apartment just can’t handle 50 guests at once?

Your neighbors are angry, the drinks run out, and suddenly, nobody’s having fun.

That’s exactly what happens to your system when you forget to add API rate limiting, but instead of noise complaints, you get slow responses, timeout, and a lot of angry users.

In this session, we will break down Little’s Law theorem in a simple way and see how it helps keep our systems fast and reliable.

Add to Calendar

Why wait for data when you can have it ready before anyone asks? In high-performance systems, every millisecond matters, and constantly fetching data on demand can slow things down.

This session explores a smarter approach: preparing data in advance instead of making repeated requests. We’ll discuss how services can shift from traditional request-response patterns to blazing-fast local lookups using strategic data snapshots and real-time updates.

Of course, speed isn’t free—there are tradeoffs. We’ll cover the challenges of keeping data fresh and the added complexity this approach brings, so you can decide when it’s worth it.

Join us to learn why some of the most performance-critical systems are moving away from API calls—and how you can apply the same techniques.

Add to Calendar

What’s the weirdest technical request you’ve ever received from your product team? We’ve had a few, but the most extreme by far was this: generate an entire book from existing data—without human intervention.
This wasn’t just a fun side project; it was a real production need, requiring precision, automation, and some unexpected technical creativity.
In this talk, we’ll explore:
The unique challenges of programmatic publishing and why writing a book with code is harder than it sounds.

How we built a millimeter perfect system that operates at scale and the libraries that made it possible: Docker, AWS Lambda, jsPdf, serverless.js, and one very surprising tool :).

How we leveraged AI to assist in the process—so we wrote an entire component in a language we don’t know.

Using js proxy to add support to fluent syntax
How we fell for a bug that once crashed a space-vehicle, and learned to revalidate our assumptions.

How we carefully selected the right library for each part of the book and turned the project into a production-ready.

This talk is a deep dive into the intersection of Node.js, automation, and publishing, packed with insights that can be applied to any large-scale content generation problem. We’ll share what worked, what didn’t, and how Node.js enabled us to implement a unique project and led us to solutions we never expected.

Add to Calendar

Neural networks are a fantastic mathematical model. But not all of us care much for Linear Algebra and Infi. In this talk we will build a neural network ground up with JavaScript. You will understand the fundamentals of a neural network and the key factors that "make it tick". Eventually, we will talk about how you can incorporate NN into your application.

Add to Calendar

How much do you really trust your dependencies?
In this 15-minute talk, we’ll take a close look at the risks hidden in the Node.js supply chain.
Through a live, simplified attack, we’ll see just how easy it is for a single npm install to introduce malicious code into your app. More importantly, we’ll cover practical ways to protect yourself - lockfiles, audits, and modern security tools.
Stay ahead of the threats and keep your code safe.

Add to Calendar

Node.js v23 now supports modules written in TypeScript, without any transpilation. Simple, right?

Not quite. There’s a lot to talk about, a lot that will explore hidden nooks and crannies in TypeScript itself, explore how the Node.js transpilation works, why it’s very fast on the one hand, but has important limitations on the other.

This talk also considers the alternatives - JSDoc Typings, esbuild/swc, and TypeScript itself,

So if you’re thinking of getting rid of your current transpilation-based or ts-node based TypeScript code in Node.js, or are thinking of starting to write TypeScript code in Node.js, this talk is for you.

Add to Calendar

How do JavaScript runtimes like Node.js, Deno, and Bun bring your code to life? This talk dives into what happens behind the scenes—how runtimes handle I/O, scheduling, and modules, sometimes even adding new features before JavaScript itself does.

As a Node.js core collaborator, I’ll break down how new language features move from proposals to real-world implementations and what makes each runtime unique.

Add to Calendar

Protecting shared sensitive shared resources from race conditions is hard enough when running in a single process. Let's make it harder: how do you do it in a distributed system? Scale it up and run it in a production system that serves millions of transactions. See where we’re going here?
In this talk, I will take you along our journey of implementing distributed locks in Node.js, how they broke, and how we evolved our algorithm over time to support thousands of requests per second in a mission-critical financial system. We will discuss different ways to implement distributed locking, using different tools and approaches. Learn how to improve performance to support more than 10,000 transactions per second which are all trying to access the same resource while running workflows on multiple data centers and how to verify it doesn’t break.

Add to Calendar

APIs are the backbone of modern software. Embracing an API-first approach helps us build scalable, maintainable, and developer-friendly applications.
In this talk we’ll explore the key advantages of API-first design and how it drives developer productivity, fosters cross-team collaboration, and future-proofs your backend architecture.

We’ll dive into TypeSpec, Microsoft’s powerful open-source tool, and demonstrate how it empowers developers to focus on creating reliable and high-performing APIs by simplifying API design, generating schemas, API specifications, client/server code and docs.

Key Takeaways:
1. Key principles and benefits of API-first design for scalable and maintainable systems.
2. Understanding working with TypeSpec, its syntax and features.
3. Enhancing productivity by automating API specification, code generation and validations with TypeSpec.

Add to Calendar

Imagine this: One day out of the blue, user complaints are piling up. “We’re losing money by the minute!”, your boss shouts. Key business metrics are sinking, yet your dashboard shows smooth latency and zero errors.
After hours of investigation, you uncover a critical bug in your service flow. With everything on fire around you, you wonder—why wasn’t there an alert?
You probably need to rethink your monitoring approach.
In this session, we’ll shift from traditional metrics to a business-driven monitoring approach.
Using Grafana, Loki, and Prometheus, we’ll set up your first business-driven dashboard. Learn to monitor crucial business flows with custom metrics, labels, and advanced log queries, building meaningful graphs and funnels.
We'll do a session of planning and building a real world business focused monitoring dashboard, showcasing the impact of this approach.
Join me to transform your monitoring strategy and elevate your role from a developer to a product owner.

Add to Calendar

Discover how Node brings SQLite natively. Learn to harness its lightweight yet rich database capabilities for efficient, performant, streamlined applications

Add to Calendar

Node.js is great for I/O-heavy tasks - but what happens when you throw massive computations and high memory loads at it? How far can you push it before things start breaking?

After 10 years of writing JavaScript for massive datasets, I've seen Node.js crash and burn under extreme CPU and RAM pressure - and I've learned how to stop it. In this talk, I'll share real-world lessons from optimizing Node.js for heavy computation, covering what works, what doesn't, and what you should absolutely avoid.

We'll dive into worker threads, memory management, native bindings, and practical optimizations that can stretch Node.js beyond its usual limits. If you've ever found yourself battling CPU bottlenecks or dealing with mysteriously high memory usage - this talk is for you!

What you’ll take away:
✅ How far Node.js can go before CPU and memory become a problem
✅ The biggest pitfalls that slow down heavy computations
✅ Practical optimizations to boost performance under extreme load
✅ How to use worker threads, buffers, and native modules effectively

Add to Calendar

Integration testing often involves complex setups, flaky tests, and maintenance overhead. Drawing from independent consulting experience, this talk demonstrates how TestContainers solves these challenges through containerized test environments. We'll cover practical patterns for database integration, network isolation, and CI optimization. Through live coding, you'll see how to implement reliable, isolated tests that catch real issues early in development.

Add to Calendar

Handling errors in TypeScript can be messy—try/catch doesn’t scale, Promises fail silently, and unexpected undefined causes headaches. Effect-TS provides a better way by making errors explicit and easy to manage.

This talk is a beginner-friendly introduction to Effect-TS. We’ll start with common problems in error handling and show how Effect-TS helps track and handle errors safely. Through real examples, you’ll learn how to manage async operations, avoid hidden failures, and write more reliable TypeScript code.

By the end, you’ll know the core concepts of Effect-TS and how to start using it in your projects.

Add to Calendar