IoT and Node.JS: How to Catch the Opportunity?

Thank you to Oleg Romanyuk for coauthoring this article.

Understand the business opportunity

In 2019, the market revenue of IoT reached $ 212 billion. There are about 26.66 billion connected IoT devices worldwide, and this number is to reach 75.44 billion by 2025. The UN estimates that, in February 2020, the world population is 7.7 billion people. A simple math operation tells us that an average person owns from 3 to 4 IoT devices. Do you have one? Maybe a smartwatch? A smart TV? Or a smart car?

Moving further, the population is expected to reach 8.1 billion people in 2025. The same math calculation shows us that, in 2025, an average person will have from 9 to 10 smart devices in their possession. Do you see where I am leading you to? Do you want to join this prosperous market niche and make your IoT device to be one of these 9 to 10?

Why Choose NodeJS for IoT Apps?

The client-side of an IoT device is represented by the hardware itself. It is programmed with C, C++, or Lua – low-level and difficult programming languages. Yet, there is not much you can do about it because of hardware limitations. Along with high performance, the users of IoT devices prioritize low cost and energy-efficiency. Thus, at least for now, you should keep working with low-level languages.

In turn, the server-side of IoT applications offers you more freedom of choice. Here, you are not limited by the hardware, so you can choose any coding language and framework you prefer. And we believe that the right one is Node.js. Here is why.

Thanks to its quick and real-time execution, simple integration with IoT protocols, and Node modules, NodeJS is a suitable solution for IoT applications. 

1. Fast execution response 

The execution speed is the first benefit of Node.js that comes to mind first. The time spent processing requests and the time when the client receives the response are quick because of several strong Node.js features. The asynchronous and single-threaded architecture of the framework allow it not to block operations and perform different requests simultaneously. Also, Node.js provides no delays; while all input and output operations are done in separate threads, each request to the web server has a single process managing the connections of those operations. The virtual machine, Google’s V8 engine, can compile the source clean code into the native machine code during the execution time, which streamlines the development. It can sync the data quickly, thus boosting the responsiveness of IoT-connected devices. 

2. Simple integration with IoT protocols 

Many processes in the IoT largely depend on integration. The benefit of Node.js is that it supports many IoT protocols, like MQTT, simplifying the back-end integration of the app with third-party services in many environments. Node js provides built-in support for creating HTTP servers, making it straightforward to implement RESTful APIs and handle HTTP requests and responses in IoT applications. Node js offers Web Socket libraries like Socket.IO, which enable real-time, interactive communication between IoT programmable devices and servers, making NodeJS suitable for IoT apps that require low-latency data exchange. The support of protocols like CoAP, AMQP, and TCP/UDP allows for building scalable and distributed IoT systems that can communicate effectively with a wide range of IoT-connected devices, services, and platforms.

3. Efficient and easier IoT development with NodeJs modules 

NPM, Node Package Manager and many other modules in NodeJS aren’t less critical for IoT development. NodeJS has more than 80 packages used to define the requirements of IoT remote devices and develop interactive electronic devices, Raspberry Pi, and more. For companies, it’s critical to stand out, and NodeJS modules help to build apps with low overloading and the highest caliber. The app developers can adapt modules to many sensors and IoT development tools to build efficient products. 

4. Scalable and portable

Node js shows its portability and scalability through features like cross-platform compatibility, modular architecture, performance optimization, and community support. Node.js was developed as an independent framework that can work on different operating systems and platforms – Windows, macOS, and Linux. Cross-platform compatibility is the one that defines Node js scalability and portability, which ensures IoT apps can work across different environments without critical modifications. With the modular architecture of Node.js, software developers can break down their apps into smaller, reusable components. To build an IoT product, the developers can use a vast ecosystem of third-party modules and libraries that accelerate development. 

5. Manages and secures data efficiently

Thanks to the non-blocking input/output model and single-threaded event loop, Node.js can handle multiple simultaneous connections and operations concurrently. It’s because Node.js efficiently uses streams and buffers in handling HTTP requests and responses. Node.js uses buffers to interact with streams, file systems, and single network communications to hold raw binary data. This method is especially useful for dealing with large amounts of data without the need to convert it to a string first. Streams and buffers work efficiently together. They emit data events as new buffers with data occur. When the Node.js server gets a request, it creates a stream and reads data into a buffer, and once that buffer gets a certain size, it sends it along in a ‘data’ event. By efficiently handling concurrent events and requests in an above-mentioned way, Node.js increases the scalability of apps through better load distribution and resource utilization. What’s more, it provides better error handling, resilience, and real-time communication flow between different parts of IoT systems. 

6. Open-source and event-driven

NodeJS is an open-source, cross-platform JavaScript runtime environment with an event-driven architecture, making it a versatile technology for IoT products. As we partly mentioned earlier, its event-driven architecture uses an asynchronous nature, allowing software developers to create lightweight apps with strong responsiveness. Let’s partly examine the key components of its event-driven architecture, which are the event emitter module, events, and listeners. Event emitter helps create objects that can implement event-driven patterns, emit events, and handle them. Its main focus is to register, emit, and create custom events in the app while representing different actions and occurrences within the system. Another component, events, is fundamental and is constantly handled within the app. They define specific actions and changes in the system’s state. This component encompasses many actions and changes, like user interactions, system issues, and data updates. Events facilitate better understanding and maintainability within the codebase by properly identifying strings and creating event payloads. Functions like listeners in NodeJS are activated when specific events are emitted. They serve to bind events, respond properly and execute events, and provide parameters and event payloads when the sections are invoked. 

In short, an event-driven architecture and all its components manage all events concurrently without waiting for another operation to complete. It has a crucial role in enhancing app performance, by reducing direct dependencies among components and allowing them to operate independently. This allows for better modularity, fostering a more adaptable and scalable architecture for a whole system.

Do you want to learn more about the advantages of Node.js development both in IoT and in general?

Read my recent story titled “What Are the Advantages of Node.JS?”. It is a concise but informative piece of reading, and I promise you will enjoy it.

Daria Hlavcheva

Head of Partner Engagement

READ THE STORY

Beware of the challenges

Entering the IoT niche is a path to success. No wonder that there are a lot of challenges and traps awaiting on your way – success is never easy to achieve. And the first and foremost challenge you should be aware of is security.

Security is one of the top problems in the IoT sphere and one of the first pitfalls you will stumble upon. So what should you do and how?

Secure authentication

Let’s start with authentication. There are a lot of tools for authentication in Node.js application development: tokens, jwt, auth0, and so on. Each has its advantages and disadvantages. Yet, you should look at them from the perspective of IoT.

On the one hand, tokens are effective but not 100 percent safe. They are a cool way for authentication as they let you identify a specific user and decide whether to grant or deny them access. A token can be encrypted with any algorithm. However, the hardware (scanners, sensors, hubs, or other IoT things) should store this token or login/password data in firmware. Respectively, attackers can steal the token if they have physical access to the hardware. The same story goes for jwt or auth0. 

On the other hand, we can use any tools for authentication on the server-side. You can easily integrate any authentication tool on the Node.js platform. There are a lot of npm (Node Package Manager) packages that allow you to do it manually: auth0, passport, jwt. There are also packages for integration with cloud IoT services: @azure-iot/authentication, aws-iot-device-sdk, etc.

Secure HTTP requests

Next, be careful with HTTP requests from your IoT devices. You should check if you get a request from a proper IoT device. Firstly, you should implement HTTPS with your IoT devices. Hardware is not a browser and you should implement HTTPS manually on it. For the server-side, you can either do it manually or use hosting with HTTPS configuration and certificates. In Node.js, it is quite easy to implement:

const express = require(‘express’);
const https = require(‘https’);
const http = require(‘http’);
const fs = require(‘fs’);
const options = {
key: fs.readFileSync(‘path/to/your/key.pem’),
cert: fs.readFileSync(path/to/your/certificate.cert’)
};
const app = express();
http.createServer(app).listen(80);
https.createServer(options, app).listen(443);

HTTPS uses SSL or TLS protocols for data encryption. However, to be sure that you have got a request from the necessary server or client, use additional data encryption. For example, this is how you can use signature:

const fetch = require(‘node-fetch’);
const verifier = crypto.createVerify(‘RSA-SHA1’)
const SIGNATURE_FORMAT = ‘base64’;
//check if it trusted url for your certificate
const trustedUrl = ‘https://trustedUrl/’
const isTrustedUrl = trustedUrl.match(url);
If (isTrustedUrl) {
verifier.update(req.body, ‘utf8’)
fetch(isTrustedUrl)
.then(certificate => {
// check signature
const isValidSignature = verifier.verify(certificate, reg.header.signature, SIGNATURE_FORMAT);
})
.catch(err => console.log(err));
}

To wrap up this part:

1. First, you have to check the trusted URL of your certificate. 
2. Then, you sign a request body by public key from your certificate.
3. Finally, you compare the signed body with the signature from the headers. 

It is extremely important to know that we get requests from proper devices and it is not the middle attack.

Check the example

PREE – finding your belongings 

PREE is a system of BLE beacons and mobile software, which helps people to stop losing their stuff. It is a lifesaver for those who often forget their phone, bag, keys, wallet, or any other valuable belongings elsewhere. The user can see the location of their item in real time and share it with trusted contacts. Once the item is out of range, they will get a notification, and so will their friends or family members. Not to spam others with notifications when they are not needed, for example, when at home, the user can mute them for a certain area.

This Internet of Things IoT system is built with Node.js, Express, and Mongo at the backend and Ionic with Cordova at the frontend. The combination of these frameworks lets us ensure the best user experience.

Validate your idea

There are many benefits to using Node.js in developing IoT products. Because of its flexibility and extensive ecosystem of packages and modules, developers can deploy efficient IoT apps. Once you have an idea for an IoT product, start validating it. You can do it in two ways. The first is to hire an idea validation team, who will help you test the viability of your product before you invest in development. The second is to hire a software design and development team, who will launch an extensive product discovery process. 

Do you have an idea for an IoT project?

If you want to learn more about Node.js development or IoT development services, let me offer you a free consultation. Just leave a message and I will get back to you as soon as possible.

Daria Hlavcheva

Head of Partner Engagement

CONTACT US