How do I use multiple programming languages in Docker?

My project, written in Node.js, runs a Python file that needs to be built. Previously, I have used a script to set up the project when pulled from GitHub. I'd like to use Docker instead but am having issues when running multiple FROMs. My understanding is that FROM creates a new image and it is for this reason that my project build fails. What is the solution to this?

My project, written in Node.js, runs a Python file that needs to be built. Previously, I have used a script to set up the project when pulled from GitHub. I'd like to use Docker instead but am having issues when running multiple FROMs. My understanding is that FROM creates a new image and it is for this reason that my project build fails. What is the solution to this?

Original Shell Script

git clone<directory>
mv <directory> <new_name>
cd <directory>
virtualenv venv
source venv/bin/activate
pip3 install -r requirements.txt 

Attempted Dockerfile

FROM python:3.6

RUN mkdir -p /usr/src/app

COPY . /usr/src/app/
WORKDIR /usr/src/app

RUN git clone<directory>
RUN mv /usr/src/app/<directory> /usr/src/app/<new_name>

RUN pip3 install -r <new_name>/requirements.txt

FROM node:11

WORKDIR /usr/src/app

RUN npm install --production

ENTRYPOINT npm start

Crafting multi-stage builds with Docker in Node.js

Crafting multi-stage builds with Docker in Node.js

Learn how you can use a multi-stage Docker build for your Node.js application. Docker multi-stage builds enable us to create more complex build pipelines without having to resort to magic tricks.

Everyone knows about Docker. It’s the ubiquitous tool for packaging and distribution of applications that seemed to come from nowhere and take over our industry! If you are reading this, it means you already understand the basics of Docker and are now looking to create a more complex build pipeline.

In the past, optimizing our Docker images has been a challenging experience. All sorts of magic tricks were employed to reduce the size of our applications before they went to production. Things are different now because support for multi-stage builds has been added to Docker.

In this post, we explore how you can use a multi-stage build for your Node.js application. For an example, we’ll use a TypeScript build process, but the same kind of thing will work for any build pipeline. So even if you’d prefer to use Babel, or maybe you need to build a React client, then a Docker multi-stage build can work for you as well.

A basic, single-stage Dockerfile for Node.js

Let’s start by looking at a basic Dockerfile for Node.js. We can visualize the normal Docker build process as shown in Figure 1 below.

Figure 1: Normal Docker build process.

We use the docker build command to turn our Dockerfile into a Docker image. We then use the docker run command to instantiate our image to a Docker container.

The Dockerfile in Listing 1 below is just a standard, run-of-the-mill Dockerfile for Node.js. You have probably seen this kind of thing before. All we are doing here is copying the package.json, installing production dependencies, copying the source code, and finally starting the application.

This Dockerfile is for regular JavaScript applications, so we don’t need a build process yet. I’m only showing you this simple Dockerfile so you can compare it to the multi-stage Dockerfile I’ll be showing you soon.

Listing 1: A run-of-the-mill Dockerfile for Node.js

FROM node:10.15.2

WORKDIR /usr/src/app
COPY package*.json ./
RUN npm install --only=production
COPY ./src ./src
CMD npm start

Listing 1 is a quite ordinary-looking Docker file. In fact, all Docker files looked pretty much like this before multi-stage builds were introduced. Now that Docker supports multi-stage builds, we can visualize our simple Dockerfile as the single-stage build process illustrated in Figure 2.

Figure 2: A single-stage build pipeline.

The need for multiple stages

We can already run whatever commands we want in the Dockerfile when building our image, so why do we even need a multi-stage build?

To find out why, let’s upgrade our simple Dockerfile to include a TypeScript build process. Listing 2 shows the upgraded Dockerfile. I’ve bolded the updated lines so you can easily pick them out.

Listing 2: We have upgraded our simple Dockerfile to include a TypeScript build process

FROM node:10.15.2

WORKDIR /usr/src/app
COPY package*.json ./
COPY tsconfig.json ./
RUN npm install
COPY ./src ./src
RUN npm run build
CMD npm start

We can easily and directly see the problem this causes. To see it for yourself, you should instantiate a container from this image and then shell into it and inspect its file system.

I did this and used the Linux tree command to list all the directories and files in the container. You can see the result in Figure 3.

Notice that we have unwittingly included in our production image all the debris of development and the build process. This includes our original TypeScript source code (which we don’t use in production), the TypeScript compiler itself (which, again, we don’t use in production), plus any other dev dependencies we might have installed into our Node.js project.

FIgure 3: The debris from development and the build process is bloating our production Docker image.
Bear in mind this is only a trivial project, so we aren’t actually seeing too much cruft left in our production image. But you can imagine how bad this would be for a real application with many sources files, many dev dependencies, and a more complex build process that generates temporary files!

We don’t want this extra bloat in production. The extra size makes our containers bigger. When our containers are bigger than needed, it means we aren’t making efficient use of our resources. The increased surface area of the container can also be a problem for security, where we generally prefer to minimize the attackable surface area of our application.

Wouldn’t it be nice if we could throw away the files we don’t want and just keep the ones we do want? This is exactly what a Docker multi-stage build can do for us.

Crafting a Dockerfile with a multi-stage build

We are going to split out Dockerfile into two stages. Figure 4 shows what our build pipeline looks like after the split.

Figure 4: A multi-stage Docker build pipeline to build TypeScript.

Our new multi-stage build pipeline has two stages: Build stage 1 is what builds our TypeScript code; Build stage 2 is what creates our production Docker image. The final Docker image produced at the end of this pipeline contains only what it needs and omits the cruft we don’t want.

To create our two-stage build pipeline, we are basically just going to create two Docker files in one. Listing 3 shows our Dockerfile with multiple stages added. The first FROM command initiates the first stage, and the second FROM command initiates the second stage.

Compare this to a regular single-stage Dockerfile, and you can see that it actually looks like two Dockerfiles squished together in one.

Listing 3: A multi-stage Dockerfile for building TypeScript code

# Build stage 1.
# This state builds our TypeScript and produces an intermediate Docker image containing the compiled JavaScript code.
FROM node:10.15.2

WORKDIR /usr/src/app
COPY package*.json ./
COPY tsconfig.json ./
RUN npm install
COPY ./src ./src
RUN npm run build

# Build stage 2.
# This stage pulls the compiled JavaScript code from the stage 1 intermediate image.
# This stage builds the final Docker image that we'll use in production.
FROM node:10.15.2

WORKDIR /usr/src/app
COPY package*.json ./
RUN npm install --only=production
COPY --from=0 /usr/src/app/build ./build
CMD npm start

To create this multi-stage Dockerfile, I simply took Listing 2 and divided it up into separate Dockerfiles. The first stage contains only what is need to build the TypeScript code. The second stage contains only what is needed to produce the final production Docker image. I then merged the two Dockerfiles into a single file.

The most important thing to note is the use of --from in the second stage. I’ve bolded this line in Listing 3 so you can easily pick it out. This is the syntax we use to pull the built files from our first stage, which we refer to here as stage 0. We are pulling the compiled JavaScript files from the first stage into the second stage.

We can easily check to make sure we got the desired result. After creating the new image and instantiating a container, I shelled in to check the contents of the file system. You can see in Figure 5 that we have successfully removed the debris from our production image.

Figure 5: We have removed the debris of development from our Docker image.

We now have fewer files in our image, it’s smaller, and it has less surface area. Yay! Mission accomplished.

But what, specifically, does this mean?

The effect of the multi-stage build

What exactly is the effect of the new build pipeline on our production image?

I measured the results before and after. Our single-stage image produced by Listing 2 weighs in at 955MB. After converting to the multi-stage build in Listing 3, the image now comes to 902MB. That’s a reasonable reduction — we removed 53MB from our image!

While 53MB seems like a lot, we have actually only shaved off just more than 5 percent of the size. I know what you’re going to say now: But Ash, our image is still monstrously huge! There’s still way too much bloat in that image.

Well, to make our image even smaller, we now need to use the alpine, or slimmed-down, Node.js base image. We can do this by changing our second build stage from node:10.15.2 to node:10.15.2-alpine.

This reduces our production image down to 73MB — that’s a huge win! Now the savings we get from discarding our debris is more like a whopping 60 percent. Alright, we are really getting somewhere now!

This highlights another benefit of multi-stage builds: we can use separate Docker base images for each of our build stages. This means you can customize each build stage by using a different base image.

Say you have one stage that relies on some tools that are in a different image, or you have created a special Docker image that is custom for your build process. This gives us a lot of flexibility when constructing our build pipelines.

How does it work?

You probably already guessed this: each stage or build process produces its own separate Docker image. You can see how this works in Figure 6.

The Docker image produced by a stage can be used by the following stages. Once the final image is produced, all the intermediate images are discarded; we take what we want for the final image, and the rest gets thrown away.

Figure 6: Each stage of a multi-stage Docker build produces an image.

Adding more stages

There’s no need to stop at two stages, although that’s often all that’s needed; we can add as many stages as we need. A specific example is illustrated in Figure 7.

Here we are building TypeScript code in stage 1 and our React client in stage 2. In addition, there’s a third stage that produces the final image from the results of the first two stages.

Figure 7: Using a Docker multi-stage build, we can create more complex build pipelines.

Pro tips

Now time to leave you with a few advanced tips to explore on your own:

  1. You can name your build stages! You don’t have to leave them as the default 0, 1, etc. Naming your build stages will make your Dockerfile more readable.
  2. Understand the options you have for base images. Using the right base image can relieve a lot of confusion when constructing your build pipeline.
  3. Build a custom base image if the complexity of your build process is getting out of hand.
  4. You can pull from external images! Just like you pull files from earlier stages, you can also pull files from images that are published to a Docker repository. This gives you an option to pre-bake an early build stage if it’s expensive and doesn’t change very often.
Conclusion and resources

Docker multi-stage builds enable us to create more complex build pipelines without having to resort to magic tricks. They help us slim down our production Docker images and remove the bloat. They also allow us to structure and modularize our build process, which makes it easier to test parts of our build process in isolation.

So please have some fun with Docker multi-stage builds, and don’t forget to have a look at the example code on GitHub.

Here’s the Docker documentation on multi-stage builds, too.

Node.js vs Python: Choosing The Right Back-End for Your Web App

Node.js vs Python: Choosing The Right Back-End for Your Web App

Choosing The Right Back-End for Your Web App between Node.js and Python. Node.js and Python are among the most popular technologies for back-end development. In this article, we'll be bold and claim that one of these technologies is winning. The question is: which one is it?

In this article, we'll be bold and claim that one of these technologies is winning. The question is: which one is it? Let's jump on in and find out.

Background and overview

Node.js and Python are among the most popular technologies for back-end development. Common knowledge holds that there are no better or worse programming languages, and that everything depends on each developer's preferences.

Yet, in this article, I am going to be brave and claim that one of these technologies – NodeJS or Python 3 – is winning. Which one will it be? Let’s see.

The criteria that I am going to consider are:

  1. Architecture
  2. Speed
  3. Syntax
  4. Scalability
  5. Extensibility
  6. Libraries
  7. Universality
  8. Learning curve
  9. Community
  10. Apps it is best suitable for

Before I jump into a detailed side-by-side comparison, you can have a look at this infographic to get a general understanding.

Brief overview


NodeJS is not a programming language but rather an open-sourced runtime environment for JavaScript. It was initially released in 2009 by Ryan Dahl. The latest version – NodeJS 12.6.0 – was released in July 2019.

The most outstanding thing about Node.js is that it is based on Google’s V8 engine. It is a virtual machine with built-in interpreter, compilers, and optimizers. Written in C++, this engine was designed by Google to be used in Google Chrome. The purpose of this engine is to compile JavaScript functions into a machine code. V8 is well-known for its high speed and constantly advancing performance.


Python is an open-sourced high-level programming language. It was first released in 1991 by Guido van Rossum. The latest version is Python 3.8, and it was released in October 2019. But Python 3.7 is still more popular.

Python mainly runs on Google’s App Engine. Also developed by Google, the App Engine lets you develop web apps with Python and allows you to benefit from numerous libraries and tools that the best Python developers use.

NodeJS vs Python: 0 – 0



Node.js is designed as an event-driven environment, which enables asynchronous input/output. A certain process is called as soon as the respective event occurs, which means that no process blocks the thread. The event-driven architecture of Node.js is perfectly suitable for the development of chat applications and web games.


By contrast, Python is not designed that way. You can use it to build an asynchronous and event-driven app with the help of special tools. Modules like asyncio make it possible to write asynchronous code in Python as it would be done in Node.js. But this library is not built in most Python frameworks, and it requires some additional hustle.

This event-driven architecture brings Node.js its first point.

NodeJS vs Python: 1 – 0



First of all, since JavaScript code in Node.js is interpreted with the V8 engine (in which Google invests heavily), Node.js's performance is remarkable.

Second, Node.js executes the code outside the web browser, so the app is more resource-efficient and performs better. This also allows you to use features that cannot be used in a browser, such as TCP sockets.

Third, the event-driven non-blocking architecture enables several requests to be processed at the same time, which accelerates code execution.

And finally, single module caching is enabled in Node.js, which reduces app loading time and makes it more responsive.


Both Python and JavaScript are interpreted languages, and they are generally slower than compiled languages, such as Java. Python is beat out by Node.js in this case.

Unlike Node.js, Python is single-flow, and requests are processed much more slowly. So, Python is not the best choice for apps that prioritize speed and performance or involve a lot of complex calculations.
Since Node.js is faster, it wins a point in terms of performance and speed.

NodeJS vs Python: 2 – 0



Syntax, for the most part, is a matter of personal preference. If I start saying that one is better and the other is worse, I know I'll face a lot of criticism and skepticism from our readers.

In fact, Node.js syntax is quite similar to the browser's JavaScript. Therefore, if you are familiar with JavaScript, you are not going to have any difficulties with Node.js.


Python’s syntax is often deemed its greatest advantage. While coding in Python, software developers need to write fewer lines of code than if they were coding in Node.js. Python's syntax is very simple, and it is free of curly brackets.

Because of this, the code is much easier to read and debug. In fact, Python code is so readable that it can be understood by clients with some technical background. But again, it depends on personal preference.

But in the end, because Python's syntax is easier to understand and learn for beginners, Python wins a point here.

NodeJS vs Python: 2 – 1



Node.js spares you the need to create a large monolithic core. You create a set of microservices and modules instead, and each of them will communicate with a lightweight mechanism and run its own process. You can easily add an extra microservice and module, which makes the development process flexible.

Also, you can easily scale a Node.js web app both horizontally and vertically. To scale it horizontally, you add new nodes to the system you have. To scale it vertically, you add extra resources to the nodes you have.

And finally in terms of typing, you have more options in Node.js than in Python. You can use weakly-typed JavaScript or strongly-typed TypeScript.


In order to scale an app, multithreading needs to be enabled. But Python does not support multithreading because it uses Global Interpreter Lock (GIL).

Although Python has libs for multithreading, it is not "true" multithreading. Even if you have multiple threads, GIL does not let the Python interpreter perform tasks simultaneously but rather makes it run only one thread at a time. Python has to use GIL even though it negatively affects performance because Python's memory management is not thread-safe.

Furthermore, Python is dynamically-typed. Yet, dynamically-typed languages are not suitable for large projects with growing development teams. As it grows, the system gradually becomes excessively complex and difficult to maintain.

Evidently, Python loses out a bit to Node.js in terms of scalability.

NodeJS vs Python: 3 – 1



Node.js can be easily customized, extended, and integrated with various tools. It can be extended with the help of built-in APIs for developing HTTP or DNS servers.

It can be integrated with Babel (a JS compiler) which facilitates front-end development with old versions of Node or the browser.

Jasmine is helpful for unit-testing, and is helpful for project monitoring and troubleshooting. For data migration, process management, and module bundling, you can use Migrat, PM2, and Webpack.

And Node.js can be extended with such frameworks as Express, Hapi, Meteor, Koa, Fastify, Nest, Restify, and others.


Python was introduced in 1991, and throughout its history a lot of development tools and frameworks have been created.

For example, Python can be integrated with popular code editor Sublime Text, which offers some additional editing features and syntax extensions.

For test automation, there is the Robot Framework. There are also a few powerful web development frameworks, such as Django, Flask, Pyramid, Web2Py, or CherryPy.

So, both networks are easily extensible, and both win a point.

Node JS vs Python: 4 – 2



In Node.js, libraries and packages are managed by NPM – the Node Package Manager. It is one of the biggest repositories of software libraries. NPM is fast, well-documented, and easy to learn to work with.


In Python, libraries and packages are managed by Pip, which stands for “Pip installs Python”. Pip is fast, reliable, and easy to use, so developers find it easy to learn to work with as well.

Again, both win a point.

Node JS vs Python: 5 – 3



Node.js is predominantly used for the back-end development of web applications. Yet, for front-end development, you use JavaScript so that both front-end and back-end share the same programming language.

With Node.js, you can develop not only web apps but also desktop and hybrid mobile apps, along with cloud and IoT solutions.

Node.js is also cross-platform, meaning that a developer can create a single desktop application that will work on Windows, Linux, and Mac. Such universality is a great way to reduce project costs since one team of developers can do it all.


Python is full-stack, so it can be used both for back-end and front-end development. Similar to Node.js, Python is cross-platform, so a Python program written on Mac will run on Linux.

Both Mac and Linux have Python pre-installed, but on Windows you need to install the Python interpreter yourself.

While Python is great for web and desktop development, it is rather weak for mobile computing. Therefore, mobile applications are generally not written in Python. As for IoT and AI solutions, the popularity of Python is growing quickly.

In terms of universality, Node.js and Python go nose to nose. It would be fair to grant each a point here.

Node JS vs Python: 6 – 4

Learning curve


Node.js is JavaScript-based and can be easily learned by beginning developers. As soon as you have some knowledge of JavaScript, mastering Node.js should not be a problem.

Installing Node.js is quite simple, but it introduces some advanced topics. For example, it may be difficult to understand its event-driven architecture at first. Event-driven architecture has an outstanding impact on app performance, but developers often need some time to master it.

Even so, the entry threshold for Node.js is still quite low. But this can mean that there are a lot of unskilled Node.js developers. This might make it harder for you to find a job in such a busy market. But if you are confident and have a great portfolio, you can easily solve this problem.

On the other hand, if you're a business owner, you might face a problem of hiring low-quality specialists. But you also can solve this problem by hiring a trusted software development agency.


If you do not know JavaScript and you have to choose what to learn – Python or Node.js – you should probably start with the former. Python may be easier to learn because its syntax is simple and compact.

Usually, writing a certain function in Python will take fewer lines of code than writing the same function in Node.js. But this is not always the case because the length of your code greatly depends on your programming style and paradigm. Another plus is that there are no curly brackets as in JavaScript.

Learning Python also teaches you how to indent your code properly since the language is indentation and whitespace sensitive. (The same is true for Node.js.) The problem with indentation and whitespace sensitive languages is that a single indentation mistake or a misplaced bracket can break your code for no obvious reason. And new developers may find it hard to troubleshoot such issues.

Installing Python is more difficult than installing Node.js. If you have Linux or Windows, you should be able to install Python with no problem. If you use MacOS, you will see that you have Python 2.0 preinstalled – but you cannot use it as it will interfere with system libraries. Instead, you need to download and use another version. When you're configuring the development environment, do not forget to select the proper version.

Both Python and Node.js are easy to learn, so it's hard to say objectively which one is simpler. It also is a matter of personal preference. So, once again both technologies receive a point.

Node JS vs Python: 7 – 5



The Node.js community is large and active. It is a mature open-sourced language with a huge user community. It's ten years after its release and developers from all over the world have grown to love this technology. As a business owner, you can easily find Node.js developers. As a developer, you can always rely on peer support.


Python is somewhat older than Node.js, and it is also open-sourced. The user community has an immense number of contributors with different levels of experience. Once again, should you be a business owner or a developer, you benefit from the large community.

Both Python and Node.js have great communities, so both receive a point.

Node JS vs Python: 8 – 6

Apps it is best suitable for


Due to its event-based architecture, Node.js perfectly suits applications that have numerous concurrent requests, heavy client-side rendering, or frequent shuffling of data from a client to a server.

Some examples include IoT solutions, real-time chatbots and messengers, and complex single-page apps.

Node.js also works well for developing real-time collaboration services or streaming platforms. However, Node.js is not the best option for developing applications that require a lot of CPU resources.


Python is suitable for the development of both small and large projects. It can be used for data science apps, which involve data analysis and visualization, for voice and face recognition systems, image-processing software, neural networks, and machine learning systems. Python can also be used for the development of 3D modeling software and games.

Both technologies let you develop a wide range of apps. Which one is more suitable depends exclusively on what you need. Therefore, choosing a better one does not make any sense. Here, neither technology gets a point because they do not compete directly in this way.

Node JS vs Python: 8 – 6

To Wrap Up

Do you remember that I said I would prove that one technology is better than the other? Good!

But you also should remember that each software project has its own needs and requirements and you should choose your technology based on those needs.

A language that works for one project may not work for another project at all.

Now, I can draw conclusions. With the 8 – 6 score, Node.js is slightly ahead of Python. Keep these results in mind when choosing Python vs JavaScript for web development.

How to Use Express.js, Node.js and MongoDB.js

How to Use Express.js, Node.js and MongoDB.js

In this post, I will show you how to use Express.js, Node.js and MongoDB.js. We will be creating a very simple Node application, that will allow users to input data that they want to store in a MongoDB database. It will also show all items that have been entered into the database.

In this post, I will show you how to use Express.js, Node.js and MongoDB.js. We will be creating a very simple Node application, that will allow users to input data that they want to store in a MongoDB database. It will also show all items that have been entered into the database.

Creating a Node Application

To get started I would recommend creating a new database that will contain our application. For this demo I am creating a directory called node-demo. After creating the directory you will need to change into that directory.

mkdir node-demo
cd node-demo

Once we are in the directory we will need to create an application and we can do this by running the command
npm init

This will ask you a series of questions. Here are the answers I gave to the prompts.

The first step is to create a file that will contain our code for our Node.js server.

touch app.js

In our app.js we are going to add the following code to build a very simple Node.js Application.

var express = require("express");
var app = express();
var port = 3000;
app.get("/", (req, res) => {
&nbsp;&nbsp;res.send("Hello World");
app.listen(port, () => {
  console.log("Server listening on port " + port);

What the code does is require the express.js application. It then creates app by calling express. We define our port to be 3000.

The app.use line will listen to requests from the browser and will return the text “Hello World” back to the browser.

The last line actually starts the server and tells it to listen on port 3000.

Installing Express

Our app.js required the Express.js module. We need to install express in order for this to work properly. Go to your terminal and enter this command.

npm install express --save

This command will install the express module into our package.json. The module is installed as a dependency in our package.json as shown below.

To test our application you can go to the terminal and enter the command

node app.js

Open up a browser and navigate to the url http://localhost:3000

You will see the following in your browser

Creating Website to Save Data to MongoDB Database

Instead of showing the text “Hello World” when people view your application, what we want to do is to show a place for user to save data to the database.

We are going to allow users to enter a first name and a last name that we will be saving in the database.

To do this we will need to create a basic HTML file. In your terminal enter the following command to create an index.html file.

touch index.html

In our index.html file we will be creating an input filed where users can input data that they want to have stored in the database. We will also need a button for users to click on that will add the data to the database.

Here is what our index.html file looks like.

<!DOCTYPE html>
    <title>Intro to Node and MongoDB<title>

    <h1>Into to Node and MongoDB<&#47;h1>
    <form method="post" action="/addname">
      <label>Enter Your Name<&#47;label><br>
      <input type="text" name="firstName" placeholder="Enter first name..." required>
      <input type="text" name="lastName" placeholder="Enter last name..." required>
      <input type="submit" value="Add Name">

If you are familiar with HTML, you will not find anything unusual in our code for our index.html file. We are creating a form where users can input their first name and last name and then click an “Add Name” button.

The form will do a post call to the /addname endpoint. We will be talking about endpoints and post later in this tutorial.

Displaying our Website to Users

We were previously displaying the text “Hello World” to users when they visited our website. Now we want to display our html file that we created. To do this we will need to change the app.use line our our app.js file.

We will be using the sendFile command to show the index.html file. We will need to tell the server exactly where to find the index.html file. We can do that by using a node global call __dirname. The __dirname will provide the current directly where the command was run. We will then append the path to our index.html file.

The app.use lines will need to be changed to
app.use("/", (req, res) => {   res.sendFile(__dirname + "/index.html"); });

Once you have saved your app.js file, we can test it by going to terminal and running node app.js

Open your browser and navigate to “http://localhost:3000”. You will see the following

Connecting to the Database

Now we need to add our database to the application. We will be connecting to a MongoDB database. I am assuming that you already have MongoDB installed and running on your computer.

To connect to the MongoDB database we are going to use a module called Mongoose. We will need to install mongoose module just like we did with express. Go to your terminal and enter the following command.
npm install mongoose --save

This will install the mongoose model and add it as a dependency in our package.json.

Connecting to the Database

Now that we have the mongoose module installed, we need to connect to the database in our app.js file. MongoDB, by default, runs on port 27017. You connect to the database by telling it the location of the database and the name of the database.

In our app.js file after the line for the port and before the app.use line, enter the following two lines to get access to mongoose and to connect to the database. For the database, I am going to use “node-demo”.

var mongoose = require("mongoose"); mongoose.Promise = global.Promise; mongoose.connect("mongodb://localhost:27017/node-demo");

Creating a Database Schema

Once the user enters data in the input field and clicks the add button, we want the contents of the input field to be stored in the database. In order to know the format of the data in the database, we need to have a Schema.

For this tutorial, we will need a very simple Schema that has only two fields. I am going to call the field firstName and lastName. The data stored in both fields will be a String.

After connecting to the database in our app.js we need to define our Schema. Here are the lines you need to add to the app.js.
var nameSchema = new mongoose.Schema({   firstName: String,   lastNameName: String });

Once we have built our Schema, we need to create a model from it. I am going to call my model “DataInput”. Here is the line you will add next to create our mode.
var User = mongoose.model("User", nameSchema);

Creating RESTful API

Now that we have a connection to our database, we need to create the mechanism by which data will be added to the database. This is done through our REST API. We will need to create an endpoint that will be used to send data to our server. Once the server receives this data then it will store the data in the database.

An endpoint is a route that our server will be listening to to get data from the browser. We already have one route that we have created already in the application and that is the route that is listening at the endpoint “/” which is the homepage of our application.

HTTP Verbs in a REST API

The communication between the client(the browser) and the server is done through an HTTP verb. The most common HTTP verbs are

The following table explains what each HTTP verb does.

HTTP Verb Operation
GET Read
POST Create
PUT Update

As you can see from these verbs, they form the basis of CRUD operations that I talked about previously.

Building a CRUD endpoint

If you remember, the form in our index.html file used a post method to call this endpoint. We will now create this endpoint.

In our previous endpoint we used a “GET” http verb to display the index.html file. We are going to do something very similar but instead of using “GET”, we are going to use “POST”. To get started this is what the framework of our endpoint will look like."/addname", (req, res) => {
Express Middleware

To fill out the contents of our endpoint, we want to store the firstName and lastName entered by the user into the database. The values for firstName and lastName are in the body of the request that we send to the server. We want to capture that data, convert it to JSON and store it into the database.

Express.js version 4 removed all middleware. To parse the data in the body we will need to add middleware into our application to provide this functionality. We will be using the body-parser module. We need to install it, so in your terminal window enter the following command.

npm install body-parser --save

Once it is installed, we will need to require this module and configure it. The configuration will allow us to pass the data for firstName and lastName in the body to the server. It can also convert that data into JSON format. This will be handy because we can take this formatted data and save it directly into our database.

To add the body-parser middleware to our application and configure it, we can add the following lines directly after the line that sets our port.

var bodyParser = require('body-parser');
app.use(bodyParser.urlencoded({ extended: true }));
Saving data to database

Mongoose provides a save function that will take a JSON object and store it in the database. Our body-parser middleware, will convert the user’s input into the JSON format for us.

To save the data into the database, we need to create a new instance of our model that we created early. We will pass into this instance the user’s input. Once we have it then we just need to enter the command “save”.

Mongoose will return a promise on a save to the database. A promise is what is returned when the save to the database completes. This save will either finish successfully or it will fail. A promise provides two methods that will handle both of these scenarios.

If this save to the database was successful it will return to the .then segment of the promise. In this case we want to send text back the user to let them know the data was saved to the database.

If it fails it will return to the .catch segment of the promise. In this case, we want to send text back to the user telling them the data was not saved to the database. It is best practice to also change the statusCode that is returned from the default 200 to a 400. A 400 statusCode signifies that the operation failed.

Now putting all of this together here is what our final endpoint will look like."/addname", (req, res) => {
  var myData = new User(req.body);
    .then(item => {
      res.send("item saved to database");
    .catch(err => {
      res.status(400).send("unable to save to database");
Testing our code

Save your code. Go to your terminal and enter the command node app.js to start our server. Open up your browser and navigate to the URL “http://localhost:3000”. You will see our index.html file displayed to you.

Make sure you have mongo running.

Enter your first name and last name in the input fields and then click the “Add Name” button. You should get back text that says the name has been saved to the database like below.

Access to Code

The final version of the code is available in my Github repo. To access the code click here. Thank you for reading !