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

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

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.

Make Hono work on Node.js

Yusuke Wada

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.

Thinking Like an Architect

Luca Mezzalira

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 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

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

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

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

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

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

WinterTC is working on standardizing the APIs of different JS runtimes to avoid bad interop and vendor lock-in. The goal is to have a universal API that can be used across different runtimes. WinterTC is now part of the ECMA technical committee and is writing specs to define which web APIs should be included in server-side JS runtimes. They also have ongoing work on the common minimum API and other emerging APIs. Visit wintertc.org for more information and to get involved.

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

Hi, I'm Anna, a staff engineer at MongoDB. Former Node.js core contributor. Passionate about character encoding. Let's do a quick refresher on character encodings. Applications communicate with the outside world through byte sequences, while working with character sequences internally. JavaScript's use of UTF16 is not entirely true, as different representations exist in JavaScript engines like V8. In August 2024, a Node.js bug related to UTF-8 and character encodings occurred. Node.js core developers are making ongoing efforts to address the bug. Understanding character encodings is important to prevent similar issues. Optimizing Node.js core work and code is crucial for performance. V8 has two string representations: one byte string (ISA88591) and two byte string (UTF-16). The fast write string method in JavaScript engines has a bug with certain characters. Lessons include the importance of name choice, better testing for fast APIs, and caution with using the latest Node.js version in production.

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

Welcome to my talk about the path to native TypeScript in Node.js. We will explore the history and popularity of TypeScript, its integration into Node.js, and the recent support it has gained. The implementation of TypeScript in Node.js faced challenges, but recent improvements in CommonJS and ESM interoperability have made it possible. TypeStripping was adopted as a solution to provide transpilation without type checking. Amaro, a package that wraps SWC, was used to integrate SWC into Node.js. There are limitations in TypeScript syntax and code mode, but improvements are being made. Future plans include bug fixing, performance improvements, and stability in upcoming Node versions.

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

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.

Bull-Ish Your Queues With BullMQ

Luca Del Puppo

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

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.

NodeJS & AI: Building Smarter Applications

Aileen Villanueva

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.

Running Java in Node.js with WebAssembly

Brendan Coll

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

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

Lock, Stock and Barrel - Simplify your Codebase

Tally Barak

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

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

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.

Try our new AI tool –&nbsp;<a href="https://product2video.com/" target="_blank" rel="noopener noreferrer">Product2Video</a> Turn product images into short videos in seconds Join the&nbsp;<a data-start="176" data-end="214" rel="noopener" target="_new" href="https://product2video.com/">waitlist</a> and help us shape the future of eCommerce content 🎁 As a thank-you, we’ll gift a <a href="https://gitnation.com/events" target="_blank" rel="noopener noreferrer">GitNation conference ticket</a> to selected users who share their feedback about our new tool!

AI-Driven personalization & NextJS Development agency

Node Congress 2025

Master Fullstack: JS Backends, DevOps, Architecture