How To Build Microservice Architecture With Node.js?

By Chintan Gor Node.js August 29, 2019 13 min read 955 Views

What if I tell you that you can develop the most scalable application out there while ensuring most efficiency and customer satisfaction rate at the same time.

It sums the dream of every entrepreneur and developer, right❓

But thanks to a microservice architecture, building scalable apps is a thriving reality in 2019.

For project managers and developers who are reading this post would agree that as soon as they start building and application, the client asks for changes, and sometimes force them to add more features.

The edits would demand a lot of editing the ongoing or a complete revamp of the source code to be able to get the desired changes.

In another case, as soon as you deploy your app, it goes viral and consumed by so many people.

Eventually, the app could not hold the number of requests and users who are using the features in the given time.

At that time, scaling and expanding the app and strengthening the application becomes necessary.

That said, scaling and improving an application is not an easy task since there is an already available source code that you need to edit.

To edit the code or to build a centralized app is again hectic and tiresome activity.

To avoid any such potential scenario, we have microservices architecture that developers can leverage to cope with any possible situation and yet build a robust application that achieves dynamic objectives.

Unlike a traditional application, which would be a centralized entity, microservice architecture is a distributed and a group of loosely-coupled features that executes large tasks by smartly leveraging API integration.

The code, logic, and features defined in the microservice architecture are highly scalable and reusable segments.

Moreover, microservices does not require a complex framework, extensive lines of codes, and robust maintenance structure.

These microservices are minimal and highly user-friendly app segments that put ease the hard work done by developers and help them attain maximum productivity.

Microservices application literally breakdown big size application into a group of small-sized applications which can work as both dependent and independent application.

Benefits Of Microservices Application


Thanks to loosely-coupled applications tied together in a microservice, the upgradation or execution of applications do not affect the rest of interconnected apps.

This will help Node JS Development Company to save a lot of time and resource since you don’t have to go for extensive editing and to test your code.

Developing microservices can be the easiest primary task for building a robust app for your goals.


Developing and managing microservice application is extremely cost-effective compared to traditional apps. That is the reason why in the future you will see this as an Emerging Trend For Node.js Development.

The significant cost-cutting happens at the time when you need a lot of less maintenance, server requirements, and scalable architecture.

Furthermore, since the number of human resources involved in the whole project would also be less, you don’t have to hire a lot of people to manage a particular application.


Everything related to microservice architecture – features, code, logic – the application can be independently upgraded and utilized on other projects as well.

All you have to do is work on the API integration and apply the code as per your choice.

In the traditional application, utilization becomes extremely tough as you have to build code from scratch for all your application types.

You cannot reuse the same block of code for other purposes.


As discussed, the microservice architecture is hugely scalable and robust; you can utilize the same code for other purposes.

That is why you don’t need a big team of skilled developers who constantly engage themselves in writing a long line of codes continuously for several hours every day.

Microservice architecture, you can get help from a single developer or manage a smaller team of developers considerably to achieve your goals.

Since we will use Node.js in our example, the whole process becomes exceptionally developer-friendly as the language is easier to learn and apply.

Quick Response Time

In our example, we are going to incorporate Node.js with microservice architecture, and the whole combination is exceptionally responsive.

So the users don’t have to wait for getting output and response to their requests. They can enjoy flawless execution provided by the microservice architecture.

Granular Control

The Microservice architecture allows loosely-coupled features and source code segments, which can be decoupled and written in different languages to utilize and keep relevant.

Means, based on your requirement and comfort, you can write your code in various languages and still attain complete control over your project execution through microservice architecture.

Cross-Platform Efficiency

Cross-Platform Development

You can leverage the same microservice features and have autonomous cross-platform compatibility to work in different environments and work remotely to execute various tasks at your convenience.

Furthermore, if you are building a feature to share your users, there might be a possibility that you get your solution from the microservice network without writing the code from scratch.

Excellent Fault Tolerance

The microservice architecture provides excellent fault-tolerance where even a particular code or feature fails to execute, then the other areas of application would keep on running and completing their tasks.

This characteristic enables excellent deliverability of the microservice architecture.

Now let’s dive deep into creating microservice architecture with the help of Node.js.

If you are associated with programming you have done basic programming or aware about the coding industry, you must have heard about Node.js.

You haven’t heard, let’s have a brief about this affordable JavaScript framework.

Node.js is a JavaScript Framework that enables seamless frontend and backend development with utmost efficiency and accuracy.

Node.js is currently one of the trustworthy and scalable coding environments that are easier to learn and comprehensive enough to even the layman.

You can build full-stack JavaScript application and entertain client-side and server-side requests with the help of its indigenously built architecture.

So, Node.js is the perfect choice for building a robust microservice architecture.

Read on to know more about the step-by-step guide to building microservice architecture.

At the end of this guide, you will have a robust source code that automatically identifies the location with the help of zip codes and also provide the distance between the two geographical areas.

You will see how Node.js makes everything easier and execute program seamlessly with the help of API integration.

Let’s create some magic and create a smart microservice architecture using Node.js.

Step 1: Install Node.js

To start building your microservice architecture using Node.js, you first need to have all the necessary software installed on your systems to develop and deploy applications built on Node.js efficiently easily.

In this example, Node.js is the foundation of everything. You can go to the official website of Node.js and find out the most suitable option of the installer based on your system configuration.

For the sake of this article, we will install Node.js and package installer from https://chocolatey.org where all the necessary commands and steps are mentioned install for a Windows’ system.

To install all the required files, you just need to write and execute a single line of code in the command prompt to the rest is assured.

You need to then open a command prompt or the PowerShell on your Windows system and enter below command.

@powershell -NoProfile -ExecutionPolicy Bypass -Command "iex ((new-object wet.webclient).DownloadString('https://chocolatey.org/install.ps1'))" && SET PATH=%PATH%;%ALLUSERSPROFILE%chocolateybin

This command communicates directly with the site and finds out all the relevant files and install them automatically.

This command is the standard format to install npm and Node.js in your system using chocolatey.

Once you write this command and hit enter, you will get a message, that would confirm your installation.

Now, you can also download and install Node.js in your system using chocolatey.org.

Type below command and hit enter.

cinst nodejs install

If everything falls appropriately, you will get an affirmation about Node.js being installed in your system.

Open command-line interface in your system and type below command to verify if the installation is done properly.

node -v

If everything is done properly, this command will return the version of the Node.js installed in your system.

Step 2: Initiate The Project Development

Now, we will initiate the project by writing below command.

$ npm init

This code will create a packaging.json file in our root directory. Ensure that you are writing this command inside the root directory of your command-line interface.

After that, you are required to download and install to unique packages namely Express and Request; the previous will be responsible for building the service, and the latter will help us to connect third-party APIs with our application.

You can do the same by writing below code in your CLI.

$ npm install express request --save

Where we have added the save flag which will add the JSON file that we have made using the command earlier.

Read also: How to Use Docker for Node.js Development?

Step 3: Creating Server

For our microservices to execute tasks and connect with other nodes, we will require a server where all the requests and information will be routed in the desired component of the microservice architecture.

To create a server, go to inside the root folder and create a file named server.js and write code below inside that file.

var express = require('express')

var app = express();

var port = process.env.PORT || 3000;

var routes = require('./api/routes');


app.listen(port, function() {

console.log('Server started on port: ' + port);


As you may observe, we have added express into our code. We have also defined the port object by the name PORT and provide its value 3000.

Next line brings a relevant object from routes.js file. Now to set the route, we will pass the app to this object.

Step 4: Defining The Routes

Now we will define routes of the project, and we will have two endpoints each having their unique location, functional, physical address, etc. The result of this endpoint will provide the distance in miles.

'use strict';

var controller = require('./controller');

module.exports = function(app) {






In the above code, thanks to module.exports, we can access the functions defined in another segment of the code. We would be able to use those functions in other files as well.

The function adds two routes where the first route acquires GET requests on /about endpoints while the other purpose captures the information at the /distance endpoint.

With the help of these two parameters defined by zipcode 1, and zipcode 2, the app captures and records data of both endpoints.

This is just a line of code that captures information and handles a couple of objects through a function. However, you will need a controller where you could initiate and manage these processes.

Step 5: Setting Up The Controller

In this step, you will know the power of Node.js. You will also know why one should always choose Node.js Framework in Web App Development.

In all the other leading languages, usually, objects and functions have independent existence and purpose of serving to the application.

When it comes to Node.js, the functions can be used as objects.

See the code below, where we will use functions as objects of another function.

'use strict';

var properties = require('../package.json')

var distance = require('../service/distance');

var controllers = {

about: function(req, res) {

var aboutInfo = {

name: properties.name,

version: properties.version




get_distance: function(req, res) {

distance.find(req, res, function(err, dist) {

if (err)






module.exports = controllers;

Inside the code above, we have created controller objects with two properties which are again functions that we have used in the code snippet mentioned in the earlier step.

The first object properties referenced package.json file that npm had created at the beginning. With the help of this declaration, we can leverage the information that is stored inside the package.json file.

Then in the about property, we parse request and response objects.

In our example, we will capture the name and version information from the package.json file and create an object which will be parsed by the about the property mentioned in the above snippet.

Step 6: Connect The API

This is the final and essential step of our small project.

First, we will use the API provided by the ZipCodeAPI.com. Please note that to access the API, you will need a key which is free if you create an account. Usually, the keys are expired within 24 hours after they are issued.

Now, we will write a code snippet to handle the call to a third-party API.

var request = require('request');

const apiKey = process.env.postalcode_key || "askcma223SFGAxclk2Sas5aMZFACXsdfwsdf452ASDa124FWQJpalzjwpsET2llaMBA";

const zipCodeURL = 'https://www.zipcodeapi.com/rest/';

var distance = {

find: function(req, res, next) {

request(zipCodeURL + apiKey

+ '/distance.json/' + req.params.zipcode1 + '/'

+ req.params.zipcode2 + '/mile',

function (error, response, body) {

if (!error && response.statusCode == 200) {

response = JSON.parse(body);


} else {

console.log(response.statusCode + response.body);

res.send({distance: -1});





module.exports = distance;

I set the name of my key and named the variable postalcode_key inside the above code.

The find function is accepting next, request, and response objects as parameters. Here, we are requesting to access a URL of the particular API services which will be handled by the callback function.

Step 7: Debug And Test The Program

Our code of microservice is written and completed. Now, we can execute and debug the code and ensure that everything is alright and good to go. This is one of the good Node.js Development Practices that you should follow.

We will also mention two zipcodes to denote two different geographical locations of the world. As the output, we should get the distance between the two locations.

Now, let’s start by writing,

$ npm install

Start your program by writing,

$ npm start

This will run your program and execute the code. You will also get the output. To verify, you need to go to a couple of landing pages in your browser.

Go to your browser and type enter below URL in the search bar.


This will give you the necessary details about the code.

Then, write below the line of code.


By searching this URL in your browser, you will get the distance between the two locations.

Now, if you are mentioning zip code which does not even exist, you will get an error. You can try this on your own.

Also, if you have made any typing or technical coding mistakes, you will also be notified in the browser. In addition to all these, there are also Node.js Frameworks Of 2019 that could of great help to a newbie.


This is the basic microservice architecture that we have built that finds out the distance between two locations by just entering respective zip codes.

With the help of API, the code verifies the authenticity of zip code and determine the distance between the locations.

We hope you had a great time reading this article and it helps you to solve the burning issues. Thank You.!


Disclaimer: We at eSparkBiz Technologies have created this blog with all the consideration and utmost care. We always strive for excellence in each of our blog posts and for that purpose, we ensure that all the information written in the blog is complete, correct, comprehensible, accurate and up-to-date. However, we can’t always guarantee that the information written in the blog correct, accurate or up-to-date. Therefore, we always advise our valuable readers not to take any kind of decisions based on the information as well as the views shared by our authors. The readers should always conduct an in-depth research before making the final decision. In addition to these, all the logos, 3rd part trademarks and screenshots of websites & mobile apps are the property of the individual owners. We’re not associated with any of them.

Chintan Gor

Chintan Gor

Enthusiastic for web app development, Chintan Gor has zeal in experimenting with his knowledge of Node.js in various aspects of development. He keeps on updating his technical know-how thus pinning his name among the topmost CTO’s in India. His contribution is penned down by him through various blogs on Node.js. He is associated with eSparkBiz – a Node.js Development Company from the past 7-8 years where one can get premium services.


Follow us

Subscribe Newsletter

Call us Today


Got any Questions?
call us Today!

+1 408 850 1488 [email protected]

Our Guides

Related Post

AngularJS vs NodeJS vs ReactJS: Which One You Should Opt For?

AngularJS vs NodeJS vs ReactJS: Which One You Should Opt For?

The success of an app primarily depends on the decision every app owner takes in choosing the right framework. Today, we will discuss Angular vs…

Everything You Need To Know About Node.js Architecture

Everything You Need To Know About Node.js Architecture

Node.js is an excellent framework that you can use to develop backend services. It takes its basis on Google Chrome's JavaScript V8 Engine. Today, we…

Step-by-Step Guide To Integrate PayPal Node.js Recurring Payments API

Step-by-Step Guide To Integrate PayPal Node.js Recurring Payments API

By facilitating online transfers, PayPal allows customers to create their account on the platform, directly linked to their credit card or checking account. Today, we’re…

Share via
Copy link