Name: Node Congress 2025
Start: 2025-04-17T14:00:00.000Z
End: 2025-04-17T19:00:00.000Z

Richard Carrigan

Varun

Luca Del Puppo

Agnieszka Labonarska

Marko Draksic

Tally Barak

Mauro Bartolomeoli

Dimitris Kiriakakis

Hunor Márton Borbély

Seungho Park

David Villamarin

Shylesh B C

Alla Kaplia

Kirill Jegorov

Jeroen van Wissen

Bernie Green

Fulya Çimendere

Alexandre Leonardo Martinek

Charles

Mindi Weik

Benjamin Nixon

Franco Gutierrez

Mangirdas Darguzis

Diogo Pedro

Missy

Carolina

Jordan Newland

Suzy Nakayama

Alexandre Ferreira

Nick M

khouchane Mahmoud

Ondrej Zicha

¿Recuerdas cuando la arquitectura de software parecía solo cajas y flechas en una pizarra? En esta masterclass, desafiaremos esa visión y exploraremos lo que realmente importa en el diseño de software moderno. Descubrirás cómo los arquitectos exitosos piensan más allá de las especificaciones técnicas, viendo la arquitectura como una historia viva moldeada por personas, equipos y necesidades en evolución. Obtendrás nuevas perspectivas sobre cómo construir sistemas que perduren y aprenderás por qué las mejores arquitecturas se tratan más de habilitar a las personas que de imponer decisiones técnicas. Únete a mí en un viaje que podría cambiar para siempre la forma en que piensas sobre la arquitectura.

Thinking Like an Architect

In modern software development, architecture is more than just selecting the right tech stack; it involves decision-making, trade-offs, and considering the context of the business and organization. Understanding the problem space and focusing on users' needs are essential. Architectural flexibility is key, adapting the level of granularity and choosing between different approaches. Holistic thinking, long-term vision, and domain understanding are crucial for making better decisions. Effective communication, inclusion, and documentation are core skills for architects. Democratizing communication, prioritizing value, and embracing adaptive architectures are key to success.

Remember when software architecture seemed like just boxes and arrows on a whiteboard? In this talk, we'll challenge that view and explore what really matters in modern software design. You will discover how successful architects think beyond tech specs, seeing architecture as a living story shaped by people, teams, and evolving needs. You'll gain fresh perspectives on building systems that last and learn why the best architectures are more about enabling people than enforcing technical decisions. Join me for a journey that might just change how you think about architecture forever.

Luca Mezzalira

¡Únete a nosotros en un divertido viaje a través del mundo de las Arquitecturas Basadas en Eventos! Exploraremos la naturaleza basada en eventos de Node.js, el Event Loop, EventEmitter, Pub/Sub y la escalabilidad con Kafka. Mira una demostración en vivo de un widget de Reacción de Emoji en acción, y aprende cómo los eventos impulsan sistemas escalables y resilientes. ¡No entres en pánico, son solo eventos, y son más fáciles de lo que piensas!

La Guía del Autoestopista para Arquitecturas Basadas en Eventos

Today's Talk introduced event-driven architectures with Node.js. The event loop in Node.js enables non-blocking interaction between components. The event emitter class is used to handle events synchronously. Redis and Apache Kafka are popular tools for event handling, with Kafka providing scalability and persistence. Kafka.js is a JavaScript library that supports transactions and compression. Server-sent events are used to send events to the client. A plugin and library are used to convert an event emitter to an async iterator. The client displays emojis and updates the vote count.

Join us on a fun journey through the world of Event-Driven Architectures! We’ll explore Node.js’s event-driven nature, the Event Loop, EventEmitter, Pub/Sub, and scaling with Kafka. Watch a live demo of an Emoji Reaction widget in action, and learn how events drive scalable, resilient systems. Don’t panic, it’s just events, and they’re easier than you think!

The Hitchiker's Guide to Event Driven Architectures

Julián Duque

Los Modelos de Lenguaje Grande (LLMs) son poderosos, pero a menudo carecen de conocimiento en tiempo real. La Generación Aumentada por Recuperación (RAG) cierra esta brecha al obtener información relevante de fuentes externas antes de generar respuestas. En esta masterclass, exploraremos cómo construir un pipeline RAG eficiente en Node.js utilizando feeds RSS como fuente de datos. Compararemos diferentes bases de datos vectoriales (FAISS, pgvector, Elasticsearch), métodos de embedding y estrategias de prueba. También cubriremos el papel crucial del chunking: dividir y estructurar datos de manera efectiva para un mejor rendimiento de recuperación.Requisitos Previos- Buen entendimiento de JavaScript o TypeScript- Experiencia con Node.js y desarrollo de API- Conocimientos básicos de bases de datos y LLMs son útiles pero no requeridos Agenda📢 Introducción a RAG💻 Demo - Aplicación de Ejemplo (RAG con Feeds RSS)📕 Bases de Datos Vectoriales (FAISS, pgvector, Elasticsearch) y Embeddings🛠️ Estrategias de Chunking para Mejor Recuperación🔬 Pruebas y Evaluación de Pipelines RAG (Precisión, Recall, Rendimiento)🏊‍♀️ Consideraciones de Rendimiento y Optimización🥟 Resumen y Preguntas y Respuestas

Construyendo un Sistema RAG en Node.js: Bases de Datos Vectoriales, Embeddings y Chunking

The Workshop covered a wide range of topics including Rack systems, language models, RAG, embedding models, RUG, Longchain, Llama setup, token-based splitting, document retrieval, Chroma installation, re-ranking techniques, evaluation metrics, and model experimentation. Participants explored components like chunking, database storage, and semantic search for document management. The importance of re-ranking models in enhancing document relevance and system performance was emphasized, along with evaluation processes for system efficiency and precision.

Large Language Models (LLMs) are powerful, but they often lack real-time knowledge. Retrieval-Augmented Generation (RAG) bridges this gap by fetching relevant information from external sources before generating responses. In this workshop, we’ll explore how to build an efficient RAG pipeline in Node.js using RSS feeds as a data source. We’ll compare different vector databases (FAISS, pgvector, Elasticsearch), embedding methods, and testing strategies. We’ll also cover the crucial role of chunking—splitting and structuring data effectively for better retrieval performance.Prerequisites- Good understanding of JavaScript or TypeScript- Experience with Node.js and API development- Basic knowledge of databases and LLMs is helpful but not required Agenda📢 Introduction to RAG💻 Demo - Example Application (RAG with RSS Feeds)📕 Vector Databases (FAISS, pgvector, Elasticsearch) &amp; Embeddings🛠️ Chunking Strategies for Better Retrieval🔬 Testing &amp; Evaluating RAG Pipelines (Precision, Recall, Performance)🏊‍♀️ Performance &amp; Optimization Considerations🥟 Summary &amp; Q&amp;A

Building a RAG System in Node.js: Vector Databases, Embeddings & Chunking

Alex Korzhikov

Pavlik Kiselev

En esta masterclass profundizaremos en la integración de la búsqueda vectorial en tus aplicaciones. A lo largo de esta masterclass, no solo comprenderás los principios fundamentales detrás de la búsqueda vectorial, sino que también cortarás a través de las palabras de moda para entender sus aplicaciones prácticas. Exploraremos cuándo la búsqueda vectorial es la herramienta adecuada para el trabajo—y cuándo no lo es—para que puedas tomar decisiones informadas en tus proyectos.Al final de la masterclass, tendrás experiencia práctica mientras construimos juntos una aplicación completamente funcional, aprovechando la búsqueda vectorial para elevar la experiencia del usuario. También cubriremos cómo probar y optimizar efectivamente tu implementación para asegurarnos de que cumpla con las demandas del mundo real. Ya sea que seas nuevo en el concepto o busques perfeccionar tus habilidades, esta masterclass te equipará con el conocimiento y las herramientas para integrar la búsqueda vectorial con confianza en tu flujo de trabajo de desarrollo.Conclusiones clave:<ul><li>- Corta a través de la moda y entiende las aplicaciones del mundo real de la búsqueda vectorial para tomar decisiones informadas en tus proyectos.</li><li>- Obtén experiencia práctica construyendo una aplicación con búsqueda vectorial para mejorar la experiencia del usuario de manera práctica.</li><li>- Aprende las mejores prácticas para probar y optimizar implementaciones de búsqueda vectorial para un rendimiento robusto en el mundo real.</li></ul>

Más Allá de las Palabras de Moda: Búsqueda Vectorial Práctica y RAG para Desarrolladores

Shabai's introduction to vector search, vector representation in data, NoSQL databases for vector storage, search techniques like cosine similarity, setting up database clusters and embedding models, handling cluster access and compute costs, using credentials for secure access, importing data and creating vector search indexes, troubleshooting authentication errors and query suggestions, optimizing vector search with entity categorization and cluster creation.

In this workshop we'll dive deep into integrating vector search into your applications. Over the course of this workshop, you'll not only grasp the core principles behind vector search but also cut through the buzzwords to understand its practical applications. We'll explore when vector search is the right tool for the job—and when it's not—so you can make informed decisions in your projects.By the end of the workshop, you'll have hands-on experience as we build a fully functioning application together, leveraging vector search to elevate the user experience. We'll also cover how to effectively test and optimize your implementation to ensure it meets real-world demands. Whether you're new to the concept or looking to refine your skills, this workshop will equip you with the knowledge and tools to integrate vector search confidently into your development workflow.Key takeaways:<ul><li>- Cut through the buzz and understand vector search's real-world applications to make informed choices in your projects.</li><li>- Gain hands-on experience building an application with vector search to enhance user experience practically.</li><li>- Learn best practices for testing and optimizing vector search implementations for robust, real-world performance.</li></ul>

Beyond Buzzwords: Practical Vector Search and RAG for Developers

Shivay Lamba

El creador de Hono habla sobre Hono. Hono es un marco web que utiliza solo APIs de estándares web y se ejecuta en Cloudflare Workers, Deno y Bun. Ahora, además de esos entornos de ejecución, también se ejecuta en Node.js utilizando un adaptador de Node.js. Sin embargo, hubo algunas dificultades en el camino. En esta sesión, hablaré sobre cómo adaptamos Hono para que funcione en Node.js, mejoramos su rendimiento y la posibilidad de que apoyemos middleware compatible con Connect.

Make Hono work on Node.js

Today's Talk is about making Hono work on Node.js. Hono is a backend for web frameworks that supports TypeScript. It started as a Cloudflare workers framework and now supports multiple runtimes. The Node.js adapter allows Hono applications to run in Node.js by converting Node.js APIs into web standard APIs. Benchmark tests show that Hono is faster than Express but slower in some core areas. The Node.js adapter has been widely used and has undergone performance improvements. Overall, adding Node.js support to Hono has been successful in reaching more users and improving quality.

The creator of Hono talks about Hono. Hono is a web framework using only Web Standard APIs and runs on Cloudflare Workers, Deno, and Bun. Now, in addition to those runtimes, it also runs on Node.js by using a Node.js adapter. However, there were some difficulties along the way. In this session, I will talk about how we adapted Hono to run on Node.js, improved its performance, and the possibility that we will support Connect-compatible middleware.

Yusuke Wada

SQLite está teniendo su Renacimiento. Se está utilizando en muchos proyectos y empresas. Bun runtime tiene su implementación de sqlite, Turso es un producto sobre SQLite, y el framework Ruby on Rails eliminó toda su dependencia de Redis a favor de SQLite para cosas como Caching y Queues.La versión 22.5.0 de Node.js introdujo el módulo `node:sqlite`. Es un módulo experimental que te permite usar SQLite de una manera muy Node.js, sin ninguna dependencia externa.En esta masterclass, aprenderás cómo usar SQLite en Node.js. Exploraremos las características actuales de `node:sqlite` y cómo usarlas. También exploraremos el futuro de SQLite en Node.js.

SQLite en Node.js Desde Dentro

Introduction to SQLite in Node.js, exploring its versatility and performance, understanding the Node SQLite module's synchronous nature, utilizing SQLite's exec method for query execution, implementing test commands, preparing queries efficiently with named placeholders, exploring sessions for database synchronization, defining custom functions in SQLite, managing database backups safely, and discussing future module plans and optimizations.

SQLite is having its Renaissance. It's being used in many projects and companies. Bun runtime has its implementation of sqlite, Turso is a product on top of SQLite, and the Ruby on Rails framework dropped all its dependency on Redis in favor o SQLite for things like Caching and Queues.Node.js version 22.5.0 introduced the `node:sqlite` module. It's an experimental module that allows you to use SQLite in a very Node.js way, without any external dependency.In this workshop, you will learn how to use SQLite in Node.js. We will explore the current `node:sqlite` features and how to use them. We will also explore the future of SQLite in Node.js.

SQLite in Node.js From Inside Out

Edy Silva

La seguridad no se trata solo de corregir errores; se trata de entender las suposiciones que hacemos (y evitar el pánico innecesario). En esta charla, profundizaremos en los modelos de amenazas de Node.js y Express, que coautoré, para desglosar en qué confían, en qué no, y por qué eso realmente importa para los desarrolladores e investigadores de seguridad.Examinaremos vulnerabilidades del mundo real que encajan dentro de estos modelos, aclararemos algunos de los conceptos erróneos de seguridad más comunes (porque no todo es un colapso crítico), y exploraremos cómo estas suposiciones de seguridad influyen en las recompensas por errores, la explotabilidad y las soluciones a largo plazo. Al final, los asistentes se irán con una mejor comprensión de lo que es un riesgo de seguridad real, lo que no lo es, y cómo construir aplicaciones que no les quiten el sueño.

¿Qué es una Vulnerabilidad y Qué No lo Es? Entendiendo los Modelos de Amenazas de Node.js y Express

In this talk, we will discuss security, vulnerabilities, and how to improve your overall security. We will explore various vulnerabilities and the difference between developer errors and misconfigurations. Understanding threat models is crucial in determining responsibility for vulnerabilities. Developers have the ultimate responsibility for handling user input, network data, and other factors. Understanding threat models, best practices, and taking ownership of dependencies are key to improving security. Security is an ongoing process that requires dedication and understanding.

Security isn’t just about fixing bugs; it’s about understanding the assumptions we make (and avoiding unnecessary panic). In this talk, we’ll dive into the Node.js and Express threat models, which I co-authored, to break down what they trust, what they don’t, and why that actually matters for developers and security researchers.We’ll take a look at real-world vulnerabilities that fit within these models, clear up some of the most common security misconceptions (because not everything is a critical meltdown), and explore how these security assumptions influence bug bounties, exploitability, and long-term fixes. By the end, attendees will walk away with a much better sense of what’s a real security risk, what isn’t, and how to build applications that won’t keep them up at night.

What is a Vulnerability and What’s Not? Making Sense of Node.js and Express Threat Models

Ulises Gascón

Las codebases grandes y heredadas a menudo sufren de dependencias enredadas, falta de límites modulares y archivos "barrel" monolíticos que agrupan muchos módulos. Esto hace que la codebase sea difícil de entender, modificar y escalar. En esta masterclass, exploraremos estrategias para "desenredar el barrel" y simplificar una codebase compleja para prepararla para la migración a una arquitectura de monorepo.Cubriremos técnicas para:- Analizar tu código en busca de dependencias cíclicas- Herramientas para ayudar a refactorizar el código- Establecer pautas de codificación y automatización para controlar la complejidad de la codebase en el futuro

Cómo Simplificar tu Codebase

This talk focuses on the challenges of working with large codebases, such as unclear module boundaries, code repetition, and cluttered flows. Dead code is identified as a major problem that adds clutter and cognitive load to developers. The abstract syntax tree (AST) is introduced as a tool for systematically accessing code. TSmorf is recommended for finding and removing dead code by traversing and manipulating the AST. Cyclic dependencies are discussed as another issue, and MADGE is suggested as a tool for identifying and resolving circular references. Barrel files are presented as a method for organizing code and resolving cyclic references. The process of replacing imports and removing empty calls is explained. The key takeaways include the importance of a good layered architecture, eliminating dead code, breaking cyclic dependencies, and reducing barrel files.

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

How to Simplify your Codebase

Muchas organizaciones tienen mucho código de Java. A medida que adoptan tecnologías más nuevas como Node.js o Cloudflare Workers, mantener la interoperabilidad con este código existente es importante. WebAssembly es un conjunto de instrucciones para una máquina virtual basada en pila. Este es el mismo tipo de máquina abstracta que utiliza la Java Virtual Machine (JVM), lo que hace posible convertir el código Java existente a WebAssembly. Esto permitiría que el código Java se "importe" directamente sin reescrituras, lo que significa que podría ejecutarse en cualquier lugar donde se soporte WebAssembly. En esta charla, describiré un proyecto de investigación que hace precisamente eso. Hablaré sobre la historia de WebAssembly, cómo se ve el bytecode de Java, cómo interpretarlo, técnicas de decompilación e implementación de objetos polimórficos.

Running Java in Node.js with WebAssembly

Hello, everyone. Welcome to my talk on running Java in Node.js with WebAssembly. Many organisations have a lot of Java code, and as they adopt newer technologies such as Node.js or CloudFloat workers, maintaining interoperability with this existing code becomes important. WebAssembly is a stack machine-based thing, like the JVM, but with a different instruction set. It improves over Asm.js with a new binary format and supports streaming compilation, SIMD, and 64-bit integers. Compiling Java code to WebAssembly involves converting JVM instructions, handling local slots, recovering if statements, and understanding control flow. Short circuit conditionals and loops are important to consider in the conversion process. Additionally, memory allocation, object creation, and program memory are key concepts. Overall, this talk explores the challenges and techniques involved in running Java in Node.js with WebAssembly.

Many organisations have a lot of Java code. As they adopt newer technologies such as Node.js or Cloudflare Workers, maintaining interoperability with this existing code is important. WebAssembly is an instruction set for a stack-based virtual machine. This is the same type of abstract machine the Java Virtual Machine (JVM) uses making it possible to convert existing Java code to WebAssembly. This would allow Java code to be "imported" directly without rewrites, meaning it could be executed anywhere WebAssembly was supported. In this talk, I'll describe a research project that does just that. I’ll speak about the history of WebAssembly, what Java bytecode looks like, how to interpret it, decompilation techniques and implementing polymorphic objects.

Brendan Coll

Imagina la conveniencia de ejecutar archivos TypeScript directamente con Node.js. Hace apenas unos años, este concepto parecía un sueño lejano. Hoy, se presenta como una emocionante característica experimental. Esta narrativa se adentra en el viaje de transformar este sueño en una realidad.

El Camino hacia TypeScript Nativo

Today's Talk discusses the integration of TypeScript in Node.js. The path to native TypeScript in Node.js is explored, including the history of user requests for native support. Implementing TypeScript in Node.js poses challenges due to differences in stability guarantees and tool compatibility. TypeStripping is a transpilation-focused implementation that removes non-JavaScript features, making it stable across TypeScript versions. The Amaro package, built on SWC, provides compatibility and speed for type stripping. Experimental Strip Types and Transform Types flags enable erasable TypeScript features. TypeScript has limitations such as namespace and enum support in JavaScript and code migration issues. TypeScript Import Types and Syntax Detection are ongoing developments. Ambiguity in syntax between JavaScript and TypeScript is addressed with an erasable syntax only flag. Future steps include bug fixing, performance improvements, and upcoming Node.js releases.

Imagine the convenience of executing TypeScript files directly with Node.js. Just a few years ago, this concept seemed like a distant dream. Today, it stands as an exciting experimental feature. This narrative dives into the journey of transforming this dream into a reality.

The Path to Native TypeScript

Marco Ippolito

La mayoría de los frameworks de JavaScript nacen del ecosistema frontend y lentamente se mueven hacia el backend como meta frameworks. AdonisJS toma el enfoque opuesto, enfatizando la solución de problemas de backend y manteniéndose agnóstico sobre el stack frontend.En esta charla, proporcionaremos una visión general de AdonisJS y cómo podría ser tu puerta de entrada para construir aplicaciones monolíticas full-stack usando TypeScript.

Presentando AdonisJS - Tu Puerta de Entrada a Aplicaciones Full-stack con TypeScript

Today we are going to talk about Adonis.js, a full-stack framework for creating web applications or JSON APIs in TypeScript and Node.js. Adonis.js is TypeScript first, embraces Node.js, and is designed for teams and individuals who prefer opinionated frameworks. We are going to build a simplistic version of Product Hunt called OS Hunt in Adonis.js. We will define routes, create a controller, and interact with the database. Adonis.js provides pre-configured tools for handling form submissions and validating user input. User authentication and registration can be implemented without third-party packages. Adonis.js integrates tightly with the Wine validation library and has support for email verification.

Most JavaScript frameworks are born out of the frontend ecosystem and slowly move toward the backend as meta frameworks. AdonisJS takes the opposite approach, emphasizing solving backend problems and staying agnostic about the frontend stack.In this talk, we will provide an overview of AdonisJS and how it could be your gateway to building full-stack monolithic applications using TypeScript.

Introducing AdonisJS - Your Gateway to Full-stack TypeScript Applications

Harminder Virk

¿Alguna vez has tenido dificultades para rastrear problemas de rendimiento en tus aplicaciones de Node.js? ¡Yo también! Puede sentirse como perseguir fantasmas en tu código. ¡Por eso estoy emocionado de compartir cómo AI puede hacer esto mucho más fácil! En esta charla, te mostraré cómo AI puede simplificar la depuración de rendimiento al analizar el uso de CPU y memoria, encontrar cuellos de botella e incluso señalar posibles fugas de memoria. No necesitas ser un experto ni pasar horas escarbando en datos, solo algunos consejos prácticos y herramientas para ayudarte a hacer que tus aplicaciones funcionen sin problemas y de manera eficiente. ¡Hagamos que la optimización del rendimiento sea menos estresante!

Usando AI como Tu Experto en Rendimiento en Node.js

Today's Talk discusses the transformation of performance monitoring with AI in Node.js. AI-powered tools can analyze massive amounts of data and provide actionable insights, making performance debugging faster and more efficient. Traditional profiling techniques are often time-consuming and require deep expertise. AI-powered diagnostics analyze data and provide recommendations for optimizing performance. AI-driven performance analysis correlates performance issues with system metrics and generates code optimization suggestions. Advancements in performance debugging include detecting CPU bottlenecks, memory leaks, and combining multiple data sources for context-aware insights. The AI-powered demo showcases the detection and optimization of performance issues in a Node.js application. Integrating AI-powered performance monitoring is straightforward and requires a mindset of continuous learning and curiosity in performance optimization.

Have you ever struggled to track performance issues in your Node.js apps? Me too—it can feel like chasing ghosts in your code! That’s why I’m excited to share how AI can make this so much easier. In this talk, I’ll show you how AI can simplify performance debugging by analyzing CPU and memory usage, finding bottlenecks, and even pointing out potential memory leaks. You don’t need to be an expert or spend hours digging through data—just some practical tips and tools to help you make your apps run smoothly and efficiently. Let’s make performance tuning less stressful!

Using AI as Your Performance Expert in Node.js

Lizz Parody

Los estándares abiertos de autorización y autenticación han estado protegiendo a los usuarios, aplicaciones y recursos durante más de una década. Eso es tiempo suficiente para que los atacantes aprendan a explotar patrones incorrectos o debilidades de implementación. Aprende sobre las mejores prácticas modernas para la seguridad de OAuth y mantén a salvo a tus usuarios y datos en nuestro paisaje tecnológico en evolución.

No es magia: eleva la seguridad de autenticación con las mejores prácticas de PKCE

The talk discusses the need to enhance auth security with Pixie Best Practices and the limitations of current standards like OAuth 2 and OpenID Connect. It introduces Pixie as an added layer of security over the authorization code flow and explains how it prevents code injection. Pixie enhances security by connecting client requests with responses from the authorization server, preventing cross-site request forgery attacks. It is recommended for public clients and will be required for all clients in the upcoming OAuth 2.1 spec. The talk also highlights the benefits of Pixie for enhancing security in web apps. Learn more about Pixie and best practices at FusionAuth, where Kim Meida, Senior Director of Developer Relations, provides developer-first auth and auth APIs.

Authorization and authentication open standards have been protecting users, apps, and resources for over a decade. That’s plenty of time for attackers to learn to exploit anti-patterns or implementation weaknesses. Learn about modern best practice for OAuth security, and keep your users and data safe in our evolving tech landscape.

It’s Not Magic: Elevate Auth Security with PKCE Best Practices

Kim Maida

Desbloquea el potencial de la IA en aplicaciones de Node.js a través de implementaciones prácticas y del mundo real. Esta sesión demuestra cómo integrar tanto modelos de IA de código abierto como cerrados para construir características inteligentes como la búsqueda semántica y agentes autónomos. Los asistentes aprenderán patrones listos para producción para sistemas RAG, incrustaciones vectoriales y agentes de IA, mientras comprenden las decisiones arquitectónicas clave detrás de cada implementación. Perfecto para desarrolladores listos para ir más allá de las llamadas básicas a la API y construir aplicaciones sofisticadas mejoradas con IA.

NodeJS & AI: Building Smarter Applications

Today's Talk explored combining Node.js and artificial intelligence to build smart applications. Two types of models, closed and open source, were discussed, with closed models accessed via an API and open source models hosted locally or on the cloud. The use of RAC (Retrieve of Method Generation) to enhance models was explained, along with the process of obtaining data and improving retrieval performance. Chunking, embedding, and vector databases were introduced as techniques for organizing and transforming data. The Talk also covered data retrieval using semantic search and the generation of human-readable answers using models. The concept of enhancing models with agents was discussed, focusing on how agents break down complex goals and utilize external functions. The use of tools and the React pattern in implementing agents was highlighted. Lastly, the Talk touched on implementing agent patterns and enhancing LLMs, with demos and code available for further exploration.

Unlock the potential of AI in Node.js applications through practical, real-world implementations. This session demonstrates how to integrate both open-source and closed AI models to build intelligent features like semantic search and autonomous agents. Attendees will learn production-ready patterns for RAG systems, vector embeddings, and AI agents while understanding the core architectural decisions behind each implementation. Perfect for developers ready to move beyond basic API calls to building sophisticated AI-enhanced applications.

Aileen Villanueva

¿Alguna vez te has enfrentado a una situación en la que necesitabas desesperadamente una cola, pero las opciones tradicionales estaban fuera de la mesa? Mi equipo se encontró con este problema exacto. Después de mucha experimentación, descubrimos una solución única utilizando Redis y BullMQ. Esta charla compartirá nuestro viaje, desde la frustración de las opciones de colas limitadas hasta la construcción de un sistema altamente escalable y ultrarrápido. Te mostraremos cómo superamos los obstáculos y logramos resultados increíbles con Redis y BullMQ.

Bull-Ish Your Queues With BullMQ

Hello, and welcome to this talk where I talk about queues and Boolean Queue. Today I want to tell you a story of a team working on a client project that needed to handle a simple queue. They approached the platform team for help, but were only given one queue, which wasn't enough. The team had to find a solution using the tools they already had, such as Posgas SQL and Elastic Cache. The first possible solution was pgboss. If you don't know pgboss, it is a simple npm package that you can install in your node application and basically create a sort of queue system on top of Posgas SQL. And expose an API to call the queues and handle the queues inside of your application. The only solution left is Elastic Cache and Redis. And in this particular scenario, what shines is BoolMQ. BoolMQ is a simple npm library that implements a fast and robust queue system on top of Redis. It can be used to decouple your code and create a microservices architecture. You can create a flow by depending on different queues and creating the result based on each queue's result. Out of the box, BoolMQ provides parallelism and concurrency. Additionally, you can have OpenTelemetry set up and a UI dashboard for queue monitoring. To create a PullMQ queue, provide a name and a connection string to Redis. The code includes a run method that continuously pushes new temperatures into the queue. The consumer uses a worker to handle data and execute queries. Close the connection when closing the Node.js process. Run the publisher to push data and the consumer to receive data. Create multiple publishers or consumers as needed. The second demo shows how to set up OpenTelemetry in your Node.js environment to track what happens inside your queues. Use BullMQ Hotel and the BullHotel instance to track telemetry for your queues. The last demo demonstrates the use of Fastify with BullMQ to create a UI for managing queues. You can do whatever you want with OpenTelemetry. The last demo showcases a Fastify application within the UI. Fastify is a simple framework for handling Node.js APIs. Set up Fastify using the Fastify adapter exposed by BullMQ, BullBoard. Expose the '/UI' API to show the UI in the server. The UI allows you to interact with the queues and view completed items. BullMQ is a straightforward solution for handling queues and can be easily scaled using Redis. For most cases, using a queue is necessary and well-documented. However, it relies on Redis, which means data loss if Redis goes down. Additionally, you'll need to learn another library. Thank you for listening!

Ever faced a situation where you desperately needed a queue, but traditional options were off the table? My team ran into this exact problem. After a lot of experimentation, we discovered a unique solution using Redis and BullMQ. This talk will share our journey – from the frustration of limited queueing options to building a highly scalable, lightning-fast system. We'll show you how we overcame the obstacles and achieved incredible results with Redis and BullMQ.

Thanks for a great talk. I'm Phil Hawksworth, head of developer relations at Deno. I'll be available for Q&A later. Connect with me on social media at philhawksworth. So he took Node and he split it, and he sorted it, and joined it, and Deno was born. But naming things is hard. I've been building for the web for 25 years. Across different places, I've observed that web developers tend to follow trends over the years. JavaScript has become ubiquitous, powering the web from the front end to the server and beyond. Node.js has played a significant role in bringing JavaScript into the mainstream, increasing its resilience. The natural evolution of JavaScript is exciting, with new tools emerging. Personally, I'm cautious about adopting new tools, but I stumbled upon Deno while building edge functions on Netlify. It is powered by Deno under the hood and resembles JavaScript. I was writing functions in JavaScript and TypeScript without realizing that Deno was powering them under the hood. I got excited about using a site generator called Loom, which led me to discover Deno. Installing Deno and running its commands got me started. Deno is an open source JavaScript, TypeScript, and WebAssembly runtime with secure defaults. It's built on V8, Rust, and Tokyo and offers a JavaScript runtime, TypeScript toolchain, package manager, and task runner. Deno is a tool that encompasses various functionalities, including testing, linting, formatting, benchmarking, and compiling. Its API is based on web standards, making it familiar to web developers. Enabling Deno in your IDE provides insights into your code and hinting across the Deno ecosystem. Deno package management allows you to import packages from the NPM or the node ecosystem to ease the transition. Managing dependencies and updating packages is simplified with Deno. Deno clean purges the cache, allowing gradual repopulation. Tasks in Deno are managed in Deno.json and can be run using the commands run or task. Deno's built-in test framework allows for running tests using the command denotest. Deno includes a built-in TypeScript and JavaScript toolchain, eliminating the need for additional configuration. Deno allows running TypeScript files without the need for compilation. It offers tools for type checking, generating type definitions, formatting code, and linting. Deno simplifies and unifies various tools, making it easier for teams to adopt a consistent toolset. Deno's security model and performance are robust. Explore examples, tutorials, the Deno Discord, Blue Sky updates, and a deep dive video to learn more about Deno. Thank you for your time!

After many years and many projects using web technologies, Phil is becoming increasingly excited about changing up some of the tools that are his usual security blanket. After repeatedly campaigning for large clients to embrace tools from the NodeJS ecosystem while it was maturing, why would he consider disrupting that?In this talk, Phil will speedrun features and utilities of Deno that have him excited, and share information about plans to help the JavaScript and TypeScript ecosystems continue to thrive. We'll look at things like package management and publishing, testing and tooling, writing and hosting serverless functions, and more. All while exposing how and why Phil was once daunted by embracing TypeScript, but is now finding new comfort in the emerging tools on offer.

Dabbling With Deno — Tales From a Web Developer Playing With a New Toy

Phil Hawksworth

I'm going to talk about character encodings, specifically a Node.js bug related to UTF-8. Two popular encodings are UTF8 and UTF16. The bug was discovered in August 2024 and was traced to a specific pull request in the Node.js core repository. The bug is caused by an incorrect implementation of the fast write string method. Lessons learned include the importance of naming conventions and thorough testing beyond coverage analysis.

Anna performs a deep dive into the anatomy of a regression that affected Node.js users in development and production in the past year, and analyzes how it gives us insight into how JS engines work under the hood and how Node.js itself is currently being developed.

What's in a Node.js Bug – A Case Study

Anna Henningsen

WinterTC is working on standardizing JS runtimes to avoid vendor lock-in and provide a universal API. This involves defining which web APIs should be included, such as URL and WebAssembly. The goal is to create a definitive list of APIs for server-side JS runtimes.

We often hear about standards, whether it be web or WinterTC or otherwise, but why are they liked and how do they actually help developers like you? This talk will explain by deep-diving into standards and WinterTC especially!

WinterTC and How Standards Help Developers

Oliver Medhurst

Hello, I'm grateful that you chose to watch my talk. Thank you. Last week, I had to run some unit tests while I was coding. Business performance can be awesome. It has very interesting and outstanding features. These test sets are overly complex. It's easy to find yourself troubleshooting for hours. VTest has almost 200 configuration options. By explaining how things work, we can answer questions about using complex third-party runners versus the built-in node.js runner. Understanding better helps avoid pitfalls, troubleshoot faster, and identify opportunities for configuring things better. The CLI layer does validation and hands over to the VTest class. It searches for test files, runs them efficiently using a pool of workers, and ensures isolation to prevent issues with dirty state. VTest uses the piscina library to facilitate work with multiple workers and improve performance. The workers prepare by setting the right globals, initializing snapshots, deciding the test runner file, and starting coverage collection. Each worker executes all the tests in a file and sends an RPC message when done. The decision to reuse or create a fresh worker is determined by the isolate configuration option. Consider spreading tests among more files to fully utilize the machine. Choose between process, thread, or VM as the worker type. In terms of isolation, you can choose between using a process, a thread, or a VM. Process is the heaviest in terms of performance cost, while thread is lighter. VM performance depends on known slower aspects like accessing globals. Process is the classic choice for stability, but thread has limitations and known issues. VM has reporting issues with memory leaks. Benchmark results showed that using multiple processes was 50% better for real-world applications, but for unit tests, one process was ten times faster. Thread was slightly faster than process, and VM was slower. The price of isolation with process worker types was approximately three minutes. Without isolation, the tests lasted only two minutes, much faster, but with a few failures. Threads showed similar results with a few failures. The risk of dealing with testing issues increases without isolation. By default, tests run sequentially inside workers, but you can configure them to run in parallel using the 'concurrent' keyword. However, tests still run sequentially despite specifying 'concurrent'. Concurrency in VTest is based on promises and requires asynchronous work. Unit tests run sequentially and concurrency has no isolation. Mocking in one test affects other tests running simultaneously. In choosing worker configurations, it depends on the context. In-file concurrency is best avoided, and the process worker type is recommended as the default. Isolation is crucial in integration tests but not mandatory in unit tests. Inside the worker, a TypeScript file is handled, and failures can occur when mocking functions. Mocking doesn't work in the worker. The worker handles TypeScript files and transpiles them using Vite server. Vite server replaces imports and hoists the mocking. Vite introduces a new module loader in the runtime. Vite hoisted the mock to the first line in the transform code to make it before the import. Additionally, Vite changes mocks to dynamic imports, ensuring that mocking works. Vite intercepts function calls on the file import level, but cannot intercept calls between functions in the same file. Moving function two to a different file or using an object export can solve this issue. Function one calls function two on the same object context. Use Spy to replace functions inside the object. Vite offers a range of plugins for different functionalities. You can fix import issues by customizing Vite's runtime. The Vite server handles dependency resolution and transformation. Consider using the built-in test runner or mockup for small-scale testing. Gain a better testing experience with Vite's customized runtime.

Modern test runners like Vitest and Jest wow us with next-level features. Think in-file concurrency, HMR, embedded Chromium, performance benchmarks - you name it. Yet behind all these goodies lies a labyrinth of runtime mechanics that tunnel deep into the JavaScript runtime. These sweet perks can quickly turn into a pitfall, from subtle mocking glitches to serious performance issues. Understanding these machines is not just a geeky tour into the heart of clever libraries - but also an insightful understanding of the V8 and code inference that will save you hours of head-scratching and help you craft more thoughtful tests. Don't like theoretical talks? Great, this one is for you.

Inside the Engine: How Modern JS Test Runners Work and the Traps They Hide

Yoni Goldberg

In this Talk, the speaker covers the fundamentals of edge computing, cloud computing, and web assembly. They explore the synergy between WebAssembly (Wasm) and Edge computing and provide a use case demonstrating how Edge utilizes Wasm and edge computing. The evolution of cloud computing to edge computing is discussed, with a focus on adding computing to the CDN layer. The recent developments in compute capabilities on CDN networks, such as edge workers and serverless functions, are highlighted. The potential of WebAssembly for backend development and distributing portable binaries is showcased, along with its support in Node.js. WebAssembly runtimes and their role in enabling quick execution and secure sandboxing at the Edge are discussed. The talk also mentions the ability to perform secure data collection and the announcement of a component registry for WebAssembly components.

Discover how WASM at the edge pushes beyond cloud limits, enabling low-latency, secure, and distributed computing. In this talk, we’ll explore Wasm patterns for edge deployments, covering performance, security, and real-world use cases that blend cloud and edge seamlessly.

From Cloud to Edge Computing - Unleashing the Power of Webassembly at the Edge

Alex Casalboni

Hello, welcome to Node Congress 2025. Node is not dead and will remain popular for a long time. Node has a large number of downloads across different platforms. Despite known vulnerabilities, older versions of Node are still widely used. Node.js is an active and thriving project with a strong focus on security. Recent updates have introduced new features and improvements, including ESM support, stable threads, and web platform compatibility. Node is governed by the OpenJS Foundation and maintained by collaborators. Consensus-seeking is important for the project's development. Start contributing and be part of the future of Node.js.

Despite the exaggerated claims about its decline, Node.js is thriving. Its continued evolution pushes the boundaries of what the modern web can do. We'll start by debunking myths about Node.js, showcasing its recent enhancements and robust performance in the tech landscape.The focus then shifts to Node.js's current role in server-side programming and cloud-native applications, emphasizing the vibrant community contributions that drive its progress. We'll also explore how integrating modern JavaScript features and the influence of emerging technologies are shaping Node.js's future, not signaling its end.Concluding, the talk projects a bright future for Node.js, identifying growth areas and dispelling any misconceptions about its relevance in the evolving world of technology.

The Alleged ‘End’ of Node.js Is Much Ado About Nothing

Paolo Insogna

Want to master Fullstack: JS Backend, DevOps, Architecture? Join a two-day conference on all things Node.js, gathering Back-end and Full-stack engineers across the globe in the cloud is here to help you staying up-to-date on the latest Node.js tech.

Node Congress

I’m attending @NodeCongress, the biggest conf on #JavaScript backends – by clicking the badge you may get a free remote ticket & join me there with 5k other #nodejs devs & 15 great speakers #deno #cloudflare #awscloud

The conference on all things Node.js, DevOps, Edge-native workers (Cloudflare &amp; others), Serverless, Deno &amp; other JavaScript backend runtimes, gathering Back-end and Full-stack engineers across the globe.

Node Congress 2025

FocusReactive

Hygraph

FusionAuth

<a href="https://fusionauth.io/">FusionAuth</a> is a developer-first, customizable Customer Identity and Access Management (CIAM) platform that makes outsourcing authentication feel like a first-class experience. Trusted by over 450 global organizations, FusionAuth provides customers of any size with a single-tenant VIP suite, the option to download and run anywhere, world-class support, and no hidden costs regardless of scale.

Any Language. Any Platform. Any Technology.

FocusReactive is a <a href="https://focusreactive.com/nextjs-agency">NextJS agency</a> with deep expertise in <a href="https://focusreactive.com/headless-cms-agency">Headless CMS</a> and <a href="https://focusreactive.com/headless-commerce-agency">Headless Commerce</a>. We partner with Vercel, Shopify, Storyblok, and Sanity to build fast, scalable, SEO-friendly platforms - and provide NextJS tech &amp; AI SEO audits to optimize existing sites.