February 16 - 18, 2021
Node Congress
Online

Node Congress 2021

The biggest event on JavaScript backends

EXPLORE THE NEW FRONTIER OF BATTLE TESTED BACKENDS A two-day conference on all things Node.js, gathering Back-end and Full-stack engineers across the globe in the cloud. Stay up-to-date on the latest Node.js tech and watch the talks from the biggest virtual event for the Node.js community.

This edition of the event has finished, the latest updates of this JavaScript Conference are available on the Brand Website.
Machine Learning in Node.js using Tensorflow.js
8 min
Machine Learning in Node.js using Tensorflow.js
The Talk introduces TensorFlow.js in Node.js for machine learning, highlighting its open-source nature and easy integration with JavaScript. It emphasizes the benefits of using Node.js, such as the ability to write machine learning models directly in JavaScript, access to the NPM ecosystem, and improved performance. The different packages available for utilizing TensorFlow.js in Node.js, including CPU, GPU, and vanilla packages, are discussed. The importance of setting up Node.js bindings to avoid blocking the main thread is mentioned, along with the availability of APIs like dfNode and TensorBoard.
Logging, Metrics, and Tracing with Nodejs
31 min
Logging, Metrics, and Tracing with Nodejs
This talk covers logging, metrics, and tracing with Node.js. It explores logging configuration with Winston and logging conventions and solutions. The talk also discusses logging dashboards and metrics, as well as metrics and distributed tracing. It touches on tracing tools and visualizations, async-await and logging in Node.js, and request-specific logging and distributed tracing. Additionally, it covers logging middleware and serverless functions, and the difference between automatic and manual instrumentation.
Instrumenting Node.js Internals
7 min
Instrumenting Node.js Internals
The Talk is about troubleshooting Node.js applications and using a tool for improved visibility and information. The tool can collect information about URLs and module imports in a server. However, it is not recommended for use in non-local environments due to performance overhead and potential bugs.
Can You Change the Behavior of a Running Node.js Process From the Outside?
30 min
Can You Change the Behavior of a Running Node.js Process From the Outside?
This talk explores how to remotely change the behavior of a Node.js process at runtime and inject a logger using the Chrome DevTool protocol. It demonstrates the power of dev tools and encourages their usage. Remote debugging is useful for debugging memory leaks in production. The method requires local machine access and has security implications, but it requires significant access and indicates a major breach. The talk emphasizes the importance of having awareness and monitoring in place for application protection.
Infrastructure as Code with a Node Focus
36 min
Infrastructure as Code with a Node Focus
Today's Talk discussed infrastructure as code using serverless Node.js with a focus on AWS Lambda and Terraform. The speaker emphasized the benefits of infrastructure as code, such as collaboration, versioning, and reproducibility. The Talk provided a step-by-step demonstration of deploying a Node.js app to AWS Lambda using Terraform. Key takeaways include the advantages of mechanized and automated processes, ephemeral state, repeatable processes, and transparency. The speaker also mentioned the importance of having DevOps experts on the team and highlighted the cost-effectiveness of serverless functions.
Examining Observability in Node.js
22 min
Examining Observability in Node.js
Today's Talk explores the concept of observability in Node.js, emphasizing the importance of understanding what's happening inside a system without needing to ship new code. The Talk covers various observability tools and techniques, including performance measurement and tracing, HeapSnapshot and Chrome DevTools, the BA Inspector, and external tools like nSolid. nSolid is highlighted as an enhanced observability tool specifically built for Node.js, offering low-input performance insights and greater security for mission-critical applications.
Testing in Production
29 min
Testing in Production
Today's Talk discusses the concept of testing in production, including challenges with staging environments and data mismatch. The use of feature flags is highlighted as a solution to enable testing in production. Automation is emphasized as a key component for efficient feature flag testing. The benefits of testing in production are increased developer velocity and confidence. Organizational requirements and resistance to testing in production are also addressed. The Talk concludes by discussing feature flag management and user segmentation in feature flag services.
How We Created the Giraffe Libraries for Time Series Data
7 min
How We Created the Giraffe Libraries for Time Series Data
I will be presenting Influx Data's open source time series graphing library GIRAFFE, which powers the visualizations of the InfluxDB dashboard and the Data Explorer. GIRAFFE is a JavaScript library based on React for charting and mapping, supporting various graph types and data sources. It offers a sandbox with examples of different graphs and provides links to GitHub, quick start guides, demos, and code samples.
Comprehensive Observability via Distributed Tracing on Node.js8
8 min
Comprehensive Observability via Distributed Tracing on Node.js8
Welcome to the session on comprehensive observability via distributed tracing on Node.js. We'll explore the challenges of microservices and troubleshoot distributed applications using an example. Correlation is the missing piece in troubleshooting distributed applications. Distributed tracing helps pinpoint issues that logging or metrics may miss, reducing mean time to resolution. It provides visualization of microservices architecture, actionable data, and enables code optimization.
Security Testing for GraphQL Backed Applications
5 min
Security Testing for GraphQL Backed Applications
StackHawk is an automated application and API security testing tool that integrates with CI/CD. It uses the ZAP scanner and supports various types of applications and APIs. StackHawk provides detailed vulnerability information and triage features to manage low-risk issues. The tool aims to seamlessly integrate into engineering workflows and make security accessible for teams.
The Security Toolbox For Node
29 min
The Security Toolbox For Node
The Talk focuses on Node application security, covering topics such as OWASP top 10 vulnerabilities, handling packages, managing data, and protecting servers. Best practices include password security, input validation, and data encryption. The importance of securing access to packages and managing data is emphasized. Encrypting data for secure communication is discussed, along with protecting servers using HTTPS and rate limiting. The challenges of security implementation and resources for learning are mentioned, as well as the use of attacker tools. Docker security and preventing IP attacks are also touched upon.
Can We Double HTTP Client Throughput?
20 min
Can We Double HTTP Client Throughput?
Today's Talk discusses HTTP clients, servers, microservices, and maximizing performance in Node.js. It covers topics such as TCP, latency, HTTP Keep-Alive, pipelining, the Node.js event loop, timeouts, and introduces the Undici library. The speaker emphasizes the importance of reusing connections, minimizing blocking, and using benchmarks to measure performance impact. Undici is highlighted as a new client for Node.js that eliminates the need for multiple agents and offers easy configuration options.
The Micro-Frontend Revolution at Amex
28 min
The Micro-Frontend Revolution at Amex
This Talk discusses the micro front-end revolution at American Express, highlighting the challenges of independent delivery and the solution of micro frontends. The architecture involves a Node.js server for server-side rendering and module composition, with Holocron modules deployed to a CDN. The development workflow includes local development environments and CI pipelines. Microfrontends are a pattern, not a set of tools, and should be implemented based on the specific use case. The adoption challenges include reworking the architecture and implementing features like Webpack and Module Federation. Communication between modules should be kept independent, and migration to micro frontends is simplified with existing microservices and Kubernetes. Server-side rendering is optional, and bundle size is limited to 250K.
From 1 to 101 Lambda Functions in Production: Evolving a Serverless Architecture
32 min
From 1 to 101 Lambda Functions in Production: Evolving a Serverless Architecture
Vacation Tracker is a serverless startup using Node.js that started with a simple lambda function and now has many lambda functions. They built a system connected to Slack and calendars, which is now used by many startups, companies, and organizations. They evolved to an event-driven architecture using CQRS and AWS AppSync with Managed GraphQL. Onboarding new developers is a challenge, but serverless allows them to assign a new environment and AWS account to each developer. Testing and monitoring are crucial, and they have successfully migrated from MongoDB to DynamoDB.
Demystifying Memory Leaks in JavaScript
33 min
Demystifying Memory Leaks in JavaScript
The Talk discusses demystifying memory leaks in JavaScript, covering topics such as memory allocation, typical memory leaks and issues, handling file descriptors and event listeners, tools and techniques for identifying memory leaks, fixing memory leaks and restarting applications, and Ruben's personal experience with memory leaks.
Safely Handling Dynamic Data with TypeScript
29 min
Safely Handling Dynamic Data with TypeScript
Top Content
This Talk discusses the safe handling of dynamic data with TypeScript using JSON Schema and TypeBox. Fastify, a web framework, allows developers to validate incoming data using JSON schema, providing type safety and error handling. TypeBox is a powerful library that allows developers to define JSON schemas and derive static types in TypeScript. The combination of JSON schema, TypeBox, and Fastify provides powerful tools for type safety and validation of dynamic data.
Node.js: the New and the Experimental
31 min
Node.js: the New and the Experimental
Beth Brix, a senior software engineer at Red Hat, discusses new and experimental features in Node.js, the release process, API stability, and the importance of user feedback. Some stable features in Node.js 15 include the abort controller, MPM7, and V886. Node 14 is the most popular version among users. The future releases of Node.js will likely include a major v8 update with new JavaScript language features. The Node community is supportive and willing to help users with migration and finding solutions.
Push Notifications: Can’t Live With Em, Can’t Live Without Em
9 min
Push Notifications: Can’t Live With Em, Can’t Live Without Em
The Talk explores the journey of a notification in a communications platform, highlighting the challenges of infrastructure engineering. Trace IDs and local storage play a crucial role in ensuring the arrival of notifications, allowing for easy debugging if they don't reach the device. The logs demonstrate the journey of a notification, reaching the app store in just 4 milliseconds.
Nodejs Runtime Performance Tips
9 min
Nodejs Runtime Performance Tips
This Talk focuses on the importance of runtime optimization in software development. It discusses the impact of unoptimized functions and the role of garbage collection. The Talk also highlights the use of profiling tools to identify and improve performance issues. Additionally, it emphasizes the importance of memory profiling to prevent memory leaks and optimize application performance.
Introduction to the AWS CDK: Infrastructure as Node
34 min
Introduction to the AWS CDK: Infrastructure as Node
The CDK is an AWS-specific infrastructure as code tool that supports multiple languages and allows you to maintain state about your application and update it without going through the same checks as making direct API calls. The CDK allows developers to write their infrastructure as well as their applications using JavaScript and TypeScript, leveraging their existing skills. It introduces an API using TypeScript and constructs to simplify building and composing CDK applications. The CDK can be used to create a variety of resources, including a static S3 site, and offers first-class support from AWS.
Don’t Try This at Home: Synchronous I/O in Node.js
32 min
Don’t Try This at Home: Synchronous I/O in Node.js
This Talk explores synchronous IO in Node.js and the advantages of asynchronous IO. It discusses exceptions to synchronous IO and approaches to achieving synchronous IO in Node.js, including using WASI and native add-ons. The Talk also covers mixing workers with atomics for synchronous IO and embedding Node.js to create a synchronous worker. Additionally, it touches on TypeScript migration, optimizations in Node.js, and experiences and advice on contributing to Node.js.
Introduction to the AWS CDK: Infrastructure as Node
34 min
Introduction to the AWS CDK: Infrastructure as Node
The AWS CDK is an infrastructure as code tool that supports multiple programming languages and helps mitigate concerns about vendor lock-in. It uses JSII to support different languages and allows you to write code once and get the same API across different languages. The CDK simplifies resource creation and management in AWS, addressing the verbosity and error-proneness of CloudFormation. CDK applications consist of apps and stacks, with stacks mapping to CloudFormation stacks. The CDK provides a more compact and familiar syntax compared to CloudFormation, making it easier for JavaScript developers to handle the entire stack.
Using Feature Flags to Enable Testing in Production
29 min
Using Feature Flags to Enable Testing in Production
Today's Talk discusses enabling tests in production, including challenges with staging environments, the use of feature flags for testing, and automating feature flag testing. It also covers running tests in production while ensuring no impact on real users, determining what to test in production, recommended tools and dependencies, and mitigating risks. The importance of testing in production and shifting the testing culture is emphasized, along with the need for a solid automation framework and managing feature flag dependencies.
How to Troubleshoot API Errors and Reduce MTTD/R
149 min
How to Troubleshoot API Errors and Reduce MTTD/R
Workshop
Gal Bashan
Gal Bashan
The benefits of Node.js to develop real-time applications at scale are very well known. As Node.js architectures get more and more complex, visualization of your microservices-based architecture is crucial. However, the visualization of microservices is incredibly complex given the scale and the transactions across them. In this workshop, you will learn how to leverage service maps to instantly understand your architecture and troubleshoot any API error.

We will write a simple Express application and explore best practices when using Express. Then, we’ll deploy the application on AWS, integrate the environment with Epsagon, and deep-dive into various features of the platform to enable immediate detection and fast troubleshooting of application errors. Goals: Visualizing your architecture, monitoring your applications, reducing your mean time to detection and recovery (MTTD and MTTR).
Who should attend?
DevOps, Engineers, Cloud Architects, IT, Software Developers, Solution Architects and Engineers, SREs, and anyone who is running microservice-based applications (Kubernetes, containers, serverless functions, and more) in the cloud.

PrerequisitesWe prefer to use VSCode for a better experience (other IDEs are fine)Preinstall npm and node        Pre-existing AWS Account - You can create a free tier here        Attendees are free to create an Epsagon account in advance here, not mandatory



IoT Center Workshop by InfluxData
131 min
IoT Center Workshop by InfluxData
Workshop
Miroslav Malecha
Miroslav Malecha
InfluxDB is an open source time series database that empowers developers to build IoT, analytics and monitoring software. It is purpose-built to handle the massive volumes and countless sources of time-stamped data produced sensors, applications and infrastructure. This workshop showcases a fully functional sample application called IoT Center that is built on InfluxDB. This application demonstrates the capabilities of the InfluxDB platform to develop a JavaScript-enabled time-series-based application. It collects, stores and displays a set of values that include temperature, humidity, pressure, CO2 concentration, air quality, as well as provide GPS coordinates from a set of IoT devices. With this data stored in InfluxDB, the application can query this data for display as well as write data back into the database.
This hands-on workshop will show students how to install this open source code to learn how to query and write to InfluxDB using the InfluxDB JavaScript client, and gain familiarity with the Flux lang query language which is designed for querying, analyzing, and acting on time series data. And finally, collect and visualize performance data of the Node JS application.
Prerequisites
Registered free InfluxDB Cloud account at https://cloud2.influxdata.comThree options available (via Google account, via Microsoft account or via email)Test login after the registration and save credentials for the workshopInstallation of the git tool (e.g. from https://git-scm.com/downloads)IoT Center cloneRun: git clone https://github.com/bonitoo-io/iot-center-v2Installed nodejs (from https://nodejs.org/en/download)Installed yarn package manager (from https://classic.yarnpkg.com/en/docs/install)Installed required packagesIn the cloned directoryRun: cd appRun: yarn install
Securing Node Applications with Automated Security Testing in CI/CD
71 min
Securing Node Applications with Automated Security Testing in CI/CD
Workshop
Scott Gerlach
Liran Tal
2 authors
We’ve all heard the buzz around pushing application security into the hands of developers, but if you’re like most companies, it has been hard to actually make this a reality. You aren’t alone - putting the culture, processes, and tooling in place to make this happen is tough - especially for sophisticated applications. Join Scott Gerlach (CSO, StackHawk) and Liran Tal (Developer Advocate, Snyk) as they dive into how you can add AppSec testing to your CI/CD pipeline to ship secure code faster.
Prerequisites:Docker is a nice to have
Web APIs with Sails
118 min
Web APIs with Sails
Workshop
Kelvin Omereshone
Kelvin Omereshone
The "Web APIs with Sails" workshop focuses on creating Node.js web APIs with the Sails framework.The workshop begins with a beginner's introduction to the Sails framework, we touch on getting started with Sails, installing Sails in your machine, then touch on Sails framework philosophy, concepts, and features.We continue with the hands-on building of a Web API in Sails from Scratch and test the endpoints with Postman. We round up writing tests for the endpoints, setting up a GitHub action to run our tests when we push to GitHub then deploy our Web API to Heroku cloud.
Prerequisites:A good understanding of JavaScript and Node.js fundamentals. I prefer to use VS Code for code editing but you can use and editor you want. I expect a preinstall of Node.js and NPM
Building Serverless Applications on AWS with TypeScript
245 min
Building Serverless Applications on AWS with TypeScript
Workshop
Slobodan Stojanović
Slobodan Stojanović
This workshop teaches you the basics of serverless application development with TypeScript. We'll start with a simple Lambda function, set up the project and the infrastructure-as-a-code (AWS CDK), and learn how to organize, test, and debug a more complex serverless application.
Table of contents:        - How to set up a serverless project with TypeScript and CDK        - How to write a testable Lambda function with hexagonal architecture        - How to connect a function to a DynamoDB table        - How to create a serverless API        - How to debug and test a serverless function        - How to organize and grow a serverless application


Materials referred to in the workshop:
https://excalidraw.com/#room=57b84e0df9bdb7ea5675,HYgVepLIpfxrK4EQNclQ9w
DynamoDB blog Alex DeBrie: https://www.dynamodbguide.com/
Excellent book for the DynamoDB: https://www.dynamodbbook.com/
https://slobodan.me/workshops/nodecongress/prerequisites.html
Learn Fastify One Plugin at a Time
128 min
Learn Fastify One Plugin at a Time
Workshop
Matteo Collina
Matteo Collina
Fastify is an HTTP framework for Node.js that focuses on providing a good developer experience without compromising on performance metrics. What makes Fastify special are not its technical details, but its community which is wide open for contributions of any kind. Part of the secret sauce is Fastify plugin architecture that enabled developers to write more than a hundred plugins.This hands-on workshop is structured around a series of exercises that covers from basics "hello world", to how to structure a project, perform database access and authentication.

https://github.com/nearform/the-fastify-workshop