The State of Node for the Enterprise

Contents

The Essence of Node.js
JavaScript on the Server
Asynchronous Programming
Module-driven Development
Small Core, Vibrant Ecosystem
New Models in Open Source
What Node.js Brings to the Enterprise
SOA for the Cloud Era
Ease of Use
Performance
Accelerate Innovation
Attract and Retain Developers
Increase Productivity
Key Success Factors for Node.js Adoption
Embracing code modularization, sharing and collaboration
Building infrastructure for a modern services-oriented application environment
Removing communication and organizational barriers
Making Node.js a first-class platform
The Node.js Maturity Curve
What NodeSource Brings to Node.js
The NodeSource Product Suite
Support and Services
Contact us

Node.js is now the most dominant and in-demand language for application development, particularly on the enterprise scale. In this annual report for executives overseeing large enterprise builds, we’ll trace the evolution and adoption of Node.js in the enterprise, as well as the directions in which the ecosystem will grow. There are often pitfalls and common mistakes made by enterprise teams when adopting the framework, so we’ll discuss how to avoid them.

The Essence of Node.js

The growing popularity and adoption of Node.js is the result of a confluence of factors. First, there is an increasing need by companies of all sizes to quickly build fast, scalable, distributed web applications. Second, large enterprises are finding that there is inherent risk associated with running large, complex monolithic applications due to the difficulty and cost of tuning, maintaining, patching, and debugging them. Third, software developers are looking to develop a skill set that prepares them for the new market reality of agile practices, continuous integration and delivery, cloud-scale application design, and a highly mobile and demanding user base.

Node.js provides a module-driven, highly scalable approach to application design, development and deployment that enables development teams to put the most desirable elements of agile methodology into practice. This can greatly reduce risk and raise developer productivity—raising developer morale in the process.

In order to understand how these gains can be achieved, it is important to understand what makes Node.js so unique and powerful.

JavaScript on the Server

At the most basic level, Node.js is a platform for running JavaScript on the server. There are some key benefits associated with this model. For example, there is already a large JavaScript developer community that is building some of the world’s most exciting web applications.

In addition, JavaScript consistently ranks among the most popular languages¹. “Developer joy” is a common theme for Node.js and this largely relates to JavaScript’s approachability as well as the high levels of productivity it affords.

JavaScript on the server with Node further establishes it as the language of the web, and its new uses on the server are helping to shape the future of the language itself.

Asynchronous Programming

Node requires developers to embrace a different mindset in the form of asynchronous programming—as opposed to the traditional serial, or sequential programming. By treating I/O as a special class of operation, developers will design highly performant applications by default, but it does come with the burden of adjusting the way the programmer thinks about the execution of their code. Node is single-threaded by nature, and while some consider this a weakness, it should instead be embraced as a win for application design.

Applications built with Node are built for predictable scalability; the idiomatic design patterns adopted by Node programmers confer robust scalability by nature without the overhead required by complicated synchronization mechanisms.

JavaScript—and Node by extension—was designed for both the web and the browser, where nothing is synchronous. Asynchronous JavaScript programs can perform many complex, parallel tasks in the browser. Node takes asynchronicity to the extreme on the server, making it the perfect choice for I/O-heavy and highly concurrent applications.

Module-driven Development

Node is a highly productive platform that is modular by nature and has a track record as a key component in an agile technology stack. Node embraces the new mantra of “disposability” that is becoming pervasive in the world of service-oriented software design. Node encourages developers to think in terms of creating small services that can be easily replaced or updated when necessary.

1 The RedMonk Programming Language Rankings: January 2015

By adopting a module-driven approach, Node developers can deconstruct the functionality of large monolithic applications and redesign them as a series of Node modules, bundled together to form a collection of services. This establishes an elegant simplicity in building scalable application functionality that improves both business and developer agility and allows for greater code-reuse.

Having development teams focusing on developing modules enables them to:

Maintain focus on essential functionality
Better test, validate and document that functionality
More easily share and collaborate with other teams

Small Core, Vibrant Ecosystem

The main risk in large monolithic applications and traditional development methods is the natural mission creep of applications and the development environments that build them. Over time, this results in products that are feature rich but bloated. Node avoids this scenario by creating a small core of essential functionality that is studiously defended and constantly debated by the Node community. This pushes experimentation to the edges and encourages a vibrant ecosystem and development culture. It also ensures that spurious functionality does not become a permanent part of the Node environment.

This ethos also extends to "Node-style" development, with developers constantly thinking about how to keep modules small and focused, and splitting apart functionality where the “do one thing well” rule is broken.

New Models in Open Source

Most IT organizations now realize the increasing difficulty of modernizing their approach to development and operations without embracing open source technology to some degree. Gartner's prediction that by 2016, “the vast majority of mainstream IT organizations will leverage non-trivial elements of open source software²” in mission-critical solutions has proven true. Today, 99% of developers report using open source tools³.

2 Widespread Use of Open-Source Software Demands Strong and Effective Governance

3 "Why More Companies Are Adopting Open Source Technology" (March 3, 2017)

Node was born in the new era of open source, embodied by the GitHub model of developer interaction, collaboration, and governance. Both Node and GitHub allow for a public and private open source development platform that empowers a growing global community of developers. Enterprises adopting Node are generally seeking to capture some of the obvious benefits of open source development practices and ethos. The culture and development workflow of Node encourages greater collaboration, communication, and code-sharing— engineering practices that often go missing as enterprises grow and change over time.

What Node.js Brings to the Enterprise

The following are the primary reasons that enterprise developers are embracing Node.js as a first-class citizen in their technology stack.

SOA for the Cloud Era

After a decade of aspirations for a Service Oriented Architecture, companies with large, monolithic code bases are seeking to break these apps up into smaller, decoupled, and more nimble services. This “unbundling of everything⁴” better exploits the cloud architecture deployed in most modern data centers. Node.js has proven its utility in this area, not only as a technology choice, but for the development methodologies it encourages.

At Netflix, all user interfaces were transitioned from Java to Node.js, streamlining the development, cutting the build times, and increasing the level of customization of its UIs for each user. This migration took place simultaneously with a move from data centers to the cloud; Node.js has enabled Netflix to adopt service oriented architecture that matches their cloud-native deployment and enables teams to rapidly iterate⁵.

4 The Unbundling of Everything, TechTarget, 2015

5 Kiran "CK" Oliver, "How Node.js Powers the Many User Interfaces of Netflix," TheNewStack: (December 3, 2015).

Ease of Use

JavaScript is quickly becoming the de facto language of the web, with Node.js as the primary server-side platform for this trend. JavaScript’s ubiquitous nature, plus an abundance of rich development tools, lowers barriers for developers crossing over from the front-end, to the front- and back-end, where Node.js finds its natural home.

This is one reason why NASA chose Node.js to build data transfer applications. JavaScript was already a familiar technology throughout the organization, which meant faster development and lower costs for a team that was already accustomed to writing JavaScript-heavy applications for data transfer. The end result—a centralized source for EVA spacesuit data—lets NASA scientists access comprehensive data 300% faster⁶.

Performance

Node.js represents an attractive compromise between performance concerns and platform approachability for developers. Thanks to asynchronous I/O, Node.js can easily make calls to multiple APIs in parallel, retrieving data from downstream sources without breaking a sweat. This asynchronous programming model encourages performant development practices that are either difficult or risky in other languages and platforms.

Performance is one of the commonly-cited reasons for large organizations to undertake the process of migrating legacy applications to Node.js. The benefits of reduced network overhead and reliability at scale were immediately clear to the team at Walmart.com, which sees more than 80 million visitors per month and up to 20,000 hits per second during the holiday shopping season⁷.

We don’t have to worry about how Node.js is going to scale, or if it is going to be reliable. Alex Grigoryan, Senior Director of Application Platform, Walmart

Read the full case study: Walmart Strives to be an Online Retail Leader with Node.js

6 Node.js Helps NASA Keep Astronauts Safe and Data Accessible

7 Walmart Strives to be an Online Retail Leader with Node.js

For similar reasons, Node.js was a critical technology choice at Uber, where the process of matching drivers with riders is key to doing business. To keep wait times low and pair riders with a vehicle, driver location data is stored in a geographic database, which is continuously updated as cars move through a city. This means a high volume of network requests across a distributed system. This is where Node.js helps Uber to shine, handling millions of requests per day.⁸

Accelerate Innovation

Node.js is excellent for quick iteration. Programs can be inspected and errors can be addressed on the fly without requiring a restart, so developers can publish and deploy new code constantly. Modular blocks of code can be reused, allowing development teams to focus on solving new problems instead of reinventing the wheel. And because Node.js uses JavaScript, applications don’t require independent front-end and back-end teams; any single developer or small team familiar with JavaScript can build a working prototype.

At Capital One, it was CIO Robert Alexander who encouraged technical teams to embrace the benefits of open source software. Node.js quickly emerged as the ideal technology to use as an orchestration layer, a choice vindicated when Node.js proved to be an excellent supporting technology during Capital One’s transition to the public cloud⁹.

Read the full case study: After Call for Innovation from C-suite, Node.js Pops Up All Over Capital One

As teams at Uber took on the challenge of delivering a consistent experience during a period of massive growth, the ability to make updates or fixes to a running process was key. Developers could inspect behavior, deploy changes, and even fix errors generated by these changes, even in a production environment, because there was no need to stop or restart a running process along the way. This in turn established a culture in which problems are solved as they come up, and developers are empowered to publish incremental changes and improvements more frequently.

8 How Uber Uses Node.js to Scale Their Business

9 After Call for Innovation from C-suite, Node.js Pops Up All Over Capital One

Attract and Retain Developers

Following the standard set by Walmart, PayPal, Netflix, and Intuit, more enterprise organizations today recognize the role Node.js plays in connecting with the vibrant open source community and positioning themselves as an attractive employer for top talent.

In addition, Node.js makes it possible for organizations to combine their front-end and back-end development groups into one unified “applications” team. The economic efficiency this creates allows organizations using Node.js to offer more competitive salaries to attract top talent.

At Capital One, development teams take the startup mantra “fail faster” to heart. Small teams take advantage of the short development cycle afforded by Node.js, and are more willing to think creatively and test new ideas, knowing that very little time is wasted even if a project flops.

By choosing technologies like Node.js, which enable a more flexible, fast-paced development process, organizations can foster a culture of creativity and problem-solving, improving productivity and increasing retention.

Increase Productivity

Large enterprises tend to have internal organizational or technological silos that can represent unnecessary business risk. These barriers need to be removed so that engineering knowledge and personnel can cross between business units and within internal business units. Node.js’s module-driven approach encourages the creation of small teams of developers to solve atomic problems of functionality that interact with those of other teams. This encourages greater interaction and cooperation between developers, which in turn leads to increased productivity.

As an example, PayPal was able to double developer productivity using Node.js, meaning it took half the number of developers to deliver an application in less time when compared to Java¹⁰.

10 Nearform Blog: Node.js becoming a go-to technology for enterprise

Key Success Factors for Node.js Adoption

Short-term focus on the following areas can increase the likelihood of successful Node.js adoption:

Embracing code modularization, sharing, and collaboration
Building the infrastructure for a true SOA environment
Removing communication and organizational barriers
Elevating Node.js to a first-class platform

Embracing code modularization, sharing and collaboration

Node.js teams are tasked with building small services of bundled functionality as one of the first steps on the road towards a true service oriented architecture. Some of these services are intended to augment or replace existing monolithic code bases.

PREVENTING MINI - MONOLITHS

There exists a very real risk of these teams building “mini-monoliths.” This is a reasonable concern for teams that have long built and maintained monolithic legacy applications. At its core, a microservices model relies on the creation of modular, reusable services that can operate independently from one another.

While there is no single “right” definition of what constitutes a microservices architecture, there are a few common traits:

A typical microservice addresses only one fairly narrow business goal or need. For instance, in the case of an online retailer, inventory and shipping would live as two independent services, and a single customer purchase would lead to interactions with both.
In a microservices model, an individual service's functionally quite simple: an incoming request is processed, and a response is generated accordingly; services communicate with one another via message bus. By contrast, monolithic applications rely on an ESB (Enterprise Service Bus) to route messages and apply business logic.
Microservices should be designed to fail gracefully, without taking down adjacent services. In the online retail example above, a shopper could complete a purchase even if the endpoint for shipping information is temporarily unavailable.

In moving to this model, it’s important to give developers latitude to explore and experiment with architectures during the transition phase. Just like the services themselves, control over the microservices model should be decentralized¹¹.

ENABLE INTERNAL COLLABORATION

Because the microservices architecture is by definition decentralized and modular, it’s important to establish an internal resource hub to take full advantage of this model. In a monolithic model, an application is typically built to be an autonomous unit, often making it difficult to make incremental changes or adjustments to a single function or feature. But a key benefit of the microservices model--the decentralized, independent services--can also bring new challenges.

An internal resource hub can provide access to established code libraries, reducing development time by providing a ready solution for challenges that have already been addressed by another developer or team. A directory of APIs and documentation providing details on how to interact with these APIs similarly encourages creative reuse of existing services. Popular tools such as Github (for collaborative code) and Swagger (for interactive API documentation) support faster and more productive development.

EMBRACE COMMUNITY RESOURCES

With its highly active base of open source contributors, there’s a constant flow of new features and software being built around and for Node.js. The Node.js ecosystem extends far beyond the core code base itself. Community-built tools, tutorials, and documentation all help to ensure that anyone developing with Node.js can find helpful solutions to common problems.

11 Smartbear: What is microservices architecture?

By building on Node’s actively-developed, open-source system, we get the benefit of lots of people making the software better without us doing anything. We can sort of sit back and it just gets better on its own, which is pretty great. Matt Ranney, Senior Staff Engineer, Uber

Package managers such as Yarn and npm add tremendous value to the Node.js ecosystem. A package manager allows developers to share, search, and use code written to solve common problems. A package (also called a module) typically addresses a single challenge or need, such as connecting to a database, using a popular UI framework, or implementing basic SSO authentication. Packages are published to a publicly-available registry, where they can be discovered, downloaded, and installed by other individuals or teams.

Due to the collaborative nature of open source code, modules are often dependent on other modules to function. This highlights another benefit provided by package managers--dependency management--which simplifies usage by automatically fetching all dependencies of a given package when it is installed.

There are also ways to publish modules privately on a public registry, as well as run a unique instance of a given registry behind an enterprise firewall.

With over half a million modules available, quality will vary wildly from one to the next. In choosing which registry to use, it’s crucial to consider the needs of engineering, infrastructure, and operations groups as well as higher-level requirements from security, legal, and other business-level teams. Due to compliance and regulatory restrictions as well as organizational policies, a tool that provides scoring and analysis of packages, such as NodeSource Certified Modules, is a better fit for some teams.

Building infrastructure for a modern services-oriented application environment

In the early stages of distributed web service development many organizations struggle with the novelties of SOA. A lack of supportive infrastructure, tools, or experience can have a negative impact on the success of development teams.

Application infrastructure for SOA is often lacking because the needs of SOA require different runtime services than monolithic applications. For instance, there is often no concept of a service registry or service discovery mechanism, there are usually no conventions around inter-service communication except for a rough agreement on REST, or REST-like interfaces, and even these are rarely well versioned and are instead are tightly coupled between services.

An ideal SOA infrastructure allows services to follow their own upgrade path, and dependencies to be expressed by versioning and discovery with a strong decoupling between different moving pieces of the larger application.

Removing communication and organizational barriers

Many organizations have a wide range of communication mediums across various teams, most of which are not compatible with each other. Communication without friction is essential to increase collaboration and enable architects, managers, engineers, and operations staff to communicate across business units.

Engineering resources and incentives must be aligned such that project teams, front line support, DevOps, and IT operations teams have a clear charter, as well as an understanding of their respective roles in achieving an advanced Node.js capability.

Some of the objectives developing an effective model are:

Understanding operational needs – IT leadership must understand operations needs and concerns that are somewhat separate from project development concerns, including logging, monitoring, health checks, production configuration, and secrets management.
Recognizing overlapping concerns – Project teams have different needs in development environments for overlapping concerns, including logging, monitoring, and configuration. These need to be reconciled with deployment concerns.
Providing incentives for shared solutions – Project teams are often strongly incentivised by existing organizational structures to produce solutions specifically for the project at hand and not to develop or support shared solutions. There is little reason, other than personal interest, to take on shared projects, since they could lead to additional responsibilities outside the scope of their normal tasking. It is important to incentivise developers to join and lead shared solutions.
Managing skills and resources – As project teams continue to expand and invest in Node.js development resources, they can quickly overtake other teams in terms of engineering numbers and expertise. Particularly as projects are put into production, the engineers on these teams will likely accrue skills and understanding that go beyond what is available to other teams. The best approach is to allow Node.js engineering resources and skills to filter organically through the company so as to avoid skill silos.
Managing tooling – As project teams expand and invest in Node.js development resources, additional tooling to support these efforts will be required and will therefore impact the budget. Establishing a controlled pattern of investment in Node.js tooling will ensure uninterrupted progress during the transition.

Making Node.js a first-class platform

Making Node.js a peer technology to traditional Java,C++ or .NET environments is essential to getting the most value out of the platform. The newness of Node.js to many operations and security teams can slow the progress of Node.js projects and delay the typically high return on investment that Node.js projects can offer.

It is vital that operations teams become comfortable with regularly updating their deployed version of Node.js in production. Some required steps toward this goal are:

Security and oprations teams should tune in to release announcements for Node.js, the Node.js Security Project and also Node.js-related announcements via the Common Vulnerabilities and Exposures (CVE)¹² system where security problems with Node.js itself and some important parts of the Node.js ecosystem are reported. The Node.js blog¹³ should be monitored for new releases. The Node.js Security Project¹⁴ should be monitored for ongoing Node.js ecosystem vulnerability announcements, and these cross-referenced with code in production.
Node.js platform vulnerabilities should be treated in the same way as vulnerabilities reported for the JVM, the CLR or RHEL, even where Node.js is not exposed directly to the internet. While it is common for new technologies to be treated as second-class citizens while the organization catches up, security cannot be allowed to lag behind.
A solid smoke test suite or plan should be developed in cooperation between development and operations teams to sanity-check upgrades to components of Node.js deployments. Operations teams should have a means to perform basic validation of the success of upgrades in order to gain confidence in deploying and upgrading an evolutionary platform like Node.js.

12 Common Vulnerabilities and Exposure

13 The Node.js blog

14 The Node Security Project

The Node.js Maturity Curve

It is important to note that a maturity curve, as applied to Node.js in particular, may not reflect a serial process along all stages of the curve. Each stage is managed and sequenced differently for every organization, and the progress realized can vary from company to company. The Node.js Maturity Curve is simply a means to identifying and solving business needs, but the ongoing progress should map to those needs being met.

Let’s consider each stage:

LABS

For some organizations, new development methods and technologies like Node.js must go through a rigorous vetting process, while others allow for a more organic method of adoption. Many start with the creation of a sandbox or lab environment from which to launch the first stages of a Node.js project. This allows for a controlled introduction of Node.js into existing environments with a minimum of disruption to current operations.

NodeSource can work with development and operations architects to determine how Node.js fits within current environments and how it can be used to speed time to market for new applications or features and relieve an organization of its design debt.

PEOPLE

Developers themselves are often the most agile and flexible resources available to IT leaders. Because of the ubiquity of JavaScript developers in enterprise development shops, the first instances of the use of Node.js often emerge from a particular need for a more robust front-end or greater scale of an existing JavaScript application.

NodeSource can help companies move towards a state of the art Node.js development team by helping them understand and practice Node.js’s module-driven development approach, the realities of asynchronous programming, and the practical realities of mainstream use of open source technologies.

PROCESS

Establishing efficient, repeatable processes that are lightweight enough to allow agile development and deployment has become a critical priority for engineering and operations teams. Because investment in Node.js projects can blur the lines between front-end and back-end teams, organizations are presented with the challenge of smoothly introducing basic—and later advanced—methods of agile development, and the deconstructing of monolithic applications using Node.js’s module-based development methods.

The table below reflects some of the elements NodeSource has identified as critical to a successful transition into a high-functioning Node.js development culture.

AREA OF CONCERN	NEEDS	SOLUTIONS (PEOPLE, PROCESS, TECHNOLOGY)
Organization & Approach	Collaboration Communication Build familiarity with Node.js Hiring & Retention	Outreach Open source community involvement Github Enterprise
Development/Engeneering	Skills Development Establish cross-functional teams API/service discoverability	Hiring Education Internal Knowledge Hub N\|Solid Certified Modules GitHub Enterprise
Deployment	Security Storage CI / CD Testing & QA	Training Internal Knowledge Hub N\|Solid Certified Modules GitHub Enterprise
Production Management	Performance Optimization Vulnerability/Security Alerts Application Monitoring Debugging	Training Internal Knowledge Hub Alerts/Notification System N\|Solid Certified Modules GitHub Enterprise

TECHNOLOGY

In a sense, technology is the least flexible and agile of resources. A wholesale commitment to a technology platform is a massive investment in time, effort and human resources. Because technology architecture forces organizations to establish standard development and operations processes, business or IT leaders sometimes use it to drive change.

NodeSource adds value here by helping organizations assess where they are on the maturity curve—in terms of architecture, people, process and technology—and then helping them to fully realize a Node.js development and deployment capability.

What NodeSource Brings to Node.js

Node.js powers the software we use every day, from web, mobile, and desktop applications to API back-ends, connected devices, and even robots. Valued for enabling increased agility, Node.js is growing in popularity as part of the long-term technology plans of many organizations.

NodeSource empowers organizations of all sizes to successfully adopt and integrate Node.js, by providing products and services that enable the development, deployment, and management of mission-critical Node.js applications.

The NodeSource Product Suite

NodeSource helps organizations run production-ready Node.js applications with greater visibility into resource usage and enhanced awareness around application performance and security. Get all the benefits of open source with the ability to optimize and future-proof your investment in digital transformation.

NodeSource’s product suite includes N|Solid, a superior Node.js runtime, along with NodeSource Certified Modules (NCM), a verified registry of third party Node.js modules. Together, these products mitigate security risk and provide deep operational visibility into mission-critical applications.

N|Solid is a fully-compatible enhanced Node.js runtime built for mission-critical applications. N|Solid enables organizations to build, manage, secure, and analyze Node.js applications with greater visibility into application behavior, system health, and security risk.

WHY CHOOSE N|SOLID?

Embrace a modern application stack and deliver growth by bringing digital transformation to legacy systems and processes.
Seize new opportunities and lay the foundation for a competitive market advantage by delivering a superior user experience.
Empower teams to deliver value faster, thanks to features that streamline development, debugging, and issue resolution.
Package vulnerability scanning that takes place in real-time--not just at runtime--helps you minimize your exposure to attacks.
Capture application performance metrics not offered by any other platform to quickly identify and fix issues, keeping uptime high and infrastructure costs under control.

"At NASA, mission-critical code is the rule, not the exception. As we transition from a legacy environment to a modern Node.js-based architecture, N|Solid, along with the support of NodeSource, is proving invaluable by allowing us to scale rapidly while staying focused on our core mission."Colin Estes, Director of Software Engineering, MRI Technologies, NASA

NodeSource Certified Modules (NCM) is a secure, private registry of trusted Node.js modules. NCM calculates a trust score for each public third-party module, monitoring for security vulnerabilities and dynamically adjusting scores in real time to identify emerging risks. Armed with an understanding of a module’s risk profile, users can confidently install third-party modules in mission-critical environments.

WHY CHOOSE CERTIFIED MODULES?

Take advantage of the massive ecosystem of open source resources available for Node.js and accelerate innovation.
Ensure compliance and minimize liability without excessive process overhead for development teams, enabling faster development and deployment cycles.
A “trust score” and a detailed breakdown for each module allows your organization to benefit from third-party code with a quantitative understanding of risk.
Keep data and services secure with ongoing vulnerability scanning that identifies emerging threats, even after your application is running in production.

Support and Services

Set your team up for success with applications and services that deliver a superior end-user experience. NodeSource offers the most trusted Node.js support, professional services, and education in the industry.

WHY CHOOSE NODE SOURCE?

Expertise. Many of our team members are leading contributors to the Node.js open source project. From minor bugs to major performance issues, there is nobody better prepared to improve and optimize your application.
Insight. Our engineers provide more than just bug fixes. Get guidance, education, and best practice recommendations on application design, architecture, and security.
Coverage. From installation and configuration to troubleshooting, training, and performance optimization, NodeSource can assist your team at every stage in the application development lifecycle.

Node.js Support from NodeSource helps companies establish and sustain enterprise-grade Node.js applications and services. Whether your team is just getting started with Node.js or managing a major production application, our support engineers can help extend the capabilities of your Development and DevOps teams.

NodeSource’s Professional Services packages are designed to provide the assistance you need at every stage of the software development lifecycle. Give your team a jump start with expert guidance on best practices and common pitfalls, get a customized road map to success with an Architecture Evaluation, and/or deliver success at scale with Performance Consulting.

NodeSource Training courses cover a broad range of Node.js topics and experience levels. Our training curriculum includes instruction for teams just getting started with Node.js, those looking to establish best practices for development, deployment, and troubleshooting, or for those tackling advanced topics like performance tuning and DevOps.

"Well-planned syllabus, subject expertise, good communicators, lots of great real-world advice and examples, flexibility in topics discussed. This was one of the best trainings I have ever attended. Engineers here were raving about the quality and usefulness of this training." Kevin Delgadillo, Sr. Manager, Product, F5 Networks

Contact us

Trusted By