React With Nodejs

Posted on  by admin

With Visual Studio, you can easily create a Node.js project and use IntelliSense and other built-in features that support Node.js. In this tutorial, you create a Node.js web app project from a Visual Studio template. Then, you create a simple app using React.

In this tutorial, you learn how to:

  • A React frontend connected to a Node backend is a rock-solid combination for any application you want to build.
  • This guide is designed to help you create full-stack projects with React as easily as possible.
  • Let's see how to set up an entire project using React and Node from scratch and deploy it to the web.
  • Make sure Node and NPM are installed on your computer.
  • You can download both at (NPM is included in your Node installation).

Use a code editor of your choice.

I am using and would personally recommend using VSCode. You can download VSCode at Make sure you have Git installed on your computer. This is necessary for deploying our application with Heroku.

Before you begin, here's a quick FAQ to introduce you to some key concepts:

  • You can get it at

    An account at We will use Heroku to publish our app to the web entirely for free.

  • First create a folder for your project, called react-node-app (for example).

    Then, drag that folder into your code editor. To create our Node project, run the following command in your terminal:. This will create a package.json file which will allow us to keep track of all our app scripts and manage any dependencies our Node app needs.

  • Our server code will live in a folder of the same name: server.

    Let's create that folder. In it, we'll place a single file, out of which we'll run our server: index.js.

  • We'll use Express to create a simple web server for us which runs on port 3001 if no value is given for the environment variable PORT (Heroku will set this value when we deploy our app).

    Then in our terminal, we will install Express as a dependency to use it:. After that, we will create a script in package.json that will start our web server when we run it with npm start:.

  • Finally, we can run our app using this script by running npm start in our terminal and we should see that it is running on port 3001:.

    We want to use our Node and Express server as an API, so that it can give our React app data, change that data, or do some other operation only a server can do. In our case, we will simply send our React app a message that says "Hello from server!"


This tutorial requires the following prerequisites:

  • in a JSON object. The code below creates an endpoint for the route /api.

    If our React app makes a GET request to that route, we respond (using res, which stands for response) with our JSON data:.

    1. Note: Make sure to place this above the app.listen function.

    2. Since we've made changes to our Node code, we need to restart our server.

    To do that, end your start script in the terminal by pressing Command/Ctrl + C.

    1. Then restart it by running npm start again. And to test this, we can simply visit http://localhost:3001/api in our browser and see our message:.

    2. After creating our backend, let's move to the frontend. Open another terminal tab and use create-react-app to create a new React project with the name client:.

  • After that, we will have a React app with all of its dependencies installed.

    The only change we have to make is to add a property called proxy to our package.json file. This will allow us to make requests to our Node server without having to provide the origin it is running on (http://localhost:3001) every time we make a network request to it:.

    Then we can start up our React app by running its start script, which is the same as our Node server. First make sure to cd into the newly-created client folder. After that, will start up on localhost:3000:.

    Now that we have a working React app, we want to use it to interact with our API. Let's see how to fetch data from the /api endpoint that we created earlier.

    1. To do so, we can head to the App.js component in our src folder and make an HTTP request using useEffect.

    2. We will make a simple GET request using the Fetch API to our backend and then have our data returned as JSON. Once we have the data returned to us, we will get the message property (to grab our greeting that we sent from the server) and then put it in a state variable called data.

This will allow us to display that message in our page if we have it.

Create a project

First, create a Node.js web app project.

  1. We are using a conditional in our JSX to say that if our data is not there yet, show the text "Loading.."

  2. Finally, let's deploy our application to the web. First, within our client folder, make sure to remove the Git repo that is automatically initialized by create-react-app.

    This is essential to deploy our app, because we are going to set up a Git repo in the root folder of our project (react-node-app), not in client:.

    When we deploy, both our Node backend and React frontend are going to be served on the same domain (i.e. We see how our requests are being handled by our Node API, so we need to write some code that will display our React app when it is requested by our user (for example, when we go to the home page of our app).

  3. We can do this back in server/index.js by adding the following code:.

    This code will first allow Node to access our built React project using the express.static function for static files. And if a GET request comes in that is not handled by our /api route, our server will respond with our React app.

  4. This code allows our React and Node app to be deployed together on the same domain.

    • Then we can tell our Node App how to do that by adding a build script to our server package.json file that builds our React app for production:. I would also recommend providing a field called "engines", where you want to specific the Node version you are using to build your project.

    • This will be used for deployment. You can get your Node version by running node -v and you can put the result in "engines" (i.e. After this, we're ready to deploy using Heroku, so make sure you have an account at

      Once you are signed in and are looking at your dashboard, you'll select New > Create New App and provide a unique app name. After that, you'll want to install the Heroku CLI on your computer so you can deploy your app whenever you make any changes using Git.

    • We can install the CLI by running:. Once that's installed, you will log in to Heroku through the CLI using the heroku login command:.

      Once you have logged in, just need to follow the deployment instructions for our created app in the "Deploy" tab. The following four commands will initialize a new Git repo for our project, add our files to it, commit them, and add a Git remote for Heroku.

    • Then the very last step is to publish our app by pushing the Heroku Git remote we just added using:. Congratulations! Our full-stack React and Node app is live!

    • When you want to make changes to your app going forward (and deploy them), you just have to use Git to add your files, commit them and then push to our Heroku remote:.

      At the end of every month, I will be releasing an exclusive course, showing you exactly how to build a complete app clone with React from start to finish.

  1. Want to be notified when the next course drops?

  2. Join the waitlist here.

    Being a popular front-end JavaScript library, React can build engaging user interfaces. On the other hand, Node.js, a server-side JavaScript environment, helps developers create scalable web apps with low latency and high functionality.

    If we combine React and Node.js, it will be highly advantageous for developers creating full-stack web applications.

    This blog will explain why you should combine these two modern technologies and how they work amazingly to build easy to maintain and quickly functioning web apps.

    Let’s get started! Node.js is created on JavaScript engine V8 in Google Chrome.

    It’s an open-source programming language that can run on multiple platforms and reduce development process and time, respectively. There is no duplication if you use the JS language and modules with the help of Node.js. Node.js enables you to create a unique back-end of your app with a JS runtime environment. It’s an event-driven language and an ideal option for data-intensive apps.

    It can run on several devices and enhance your code execution speed. According to W3Tech, almost 30 million websites use Node.js. Since Node utilizes a single-threaded model, it ignores buffering while working on input/output operations.

    You can use this full-stack JavaScript framework for both server-side and client-side apps. Node gives improved scalability as compared to other JS servers. It enables scaling in vertical and horizontal directions.

    It enables efficient code execution. After all, non-blocking I/O operations back up its runtime environment. Since it is built on Chrome’s V8 JS engine, Node can enhance your app performance by 50%.

    Non-blocking, asynchronous, and event-driven. Extremely scalable yet single-threaded. More viable to accelerate the development process. Cross-platform compatibility. Quick data streaming and no buffering.

  1. Fast code implementation.

  2. Utilizes JavaScript.

    Data streaming purposes. Complex SPAs (Single Page Applications). Server-side proxy. ReactJS is a front-end JavaScript library that enables the creation of reusable UI elements. It helps build large web apps with data-driven, dynamic views.

    Moreover, it keeps up with high responsiveness and functionality across multiple devices. According to Stack Overflow developer survey, React.js is the most commonly used web framework.

    The simple design model of React gives users convenience and ease to build scalable web applications without any knowledge of complex frameworks or programming languages.

    Some popular apps that use ReactJS include WhatsApp, Instagram, Netflix, Uber, Airbnb, etc. React is more SEO-friendly than other front-end JavaScript frameworks. It offers detailed documentation with multiple resources and tutorials to jumpstart your learning. A developer with JavaScript knowledge can immediately start working with React.js. It accelerates the performance due to Virtual DOM.

    React enables developers to use several components for building web apps and improves the dynamic web app development process. Multiple components.

    One-way data binding. JavaScript Syntax Extension (JSX). Conditional Statements. High performance. Single page applications (SPAs). Building large social media sites. Web browsing apps. Creating user interfaces.

    Dynamic libraries. Node.js enables the creation of scalable and quick back-end RESTful APIs. On the other hand, React is a front-end library that creates interactive user interfaces.

    With both tools, you can fast build complex and scalable web apps. Node is the most popular platform for hosting and running web servers for React apps. After all, using NPM (Node Package Manager), you can install any package with NPM command-line interface CLI.

Add npm packages

This app requires the following npm modules to run correctly:

  • Moreover, Node utilizes Webpack and other modules to turn a React application into an easily compilable single file.
  • There are specific reasons to use the deadly combination of Node.js and React for web app development.
  • Here are a few:.
  • The combination of Node and React allows developers to build dynamic, large, data-driven web apps that are responsive across multiple devices.
  • It would help if you had scalability while working on large projects and maintaining your website’s performance.
  • MERN Stack means MongoDB, Express, React, and Node.js.
  • And no better combo than these frameworks can provide a unique dimension to a website.
  • You can use Node.js with MERN Stack alongside React.js.

To install a package:

  1. Hence, you can use the Node and React combination for web app development.

  2. Read also: MEAN Stack Vs MERN Stack: A Comparison Between the Two Tech Stacks. Creating JSON (JavaScript Object Notation) APIs for web development is competent due to the high code reusability and access to immediate code sharing in React.js.

    And Node.js can effectively allow this. If your business app handles real-time data management or aims to build a data streaming app, you should use Node.js as your app requires an ongoing server connection. When using the combination of React and Node for web app development, you can receive a high ROI and save your money and time.

    After all, these technologies work excellently to offer an effective platform for building rapid functioning and easy-to-maintain websites. Does your business require a single-page app with asynchronous data loading?

    Then, you must select React with Node back-end as it allows building a lightweight back-end model through callback functions.

    With the combination of Node and React, developers don’t require learning complex back-end languages like Python or Ruby.

Instead of using the UI to search for and add the rest of the packages one at a time, you can paste the required package code into package.json.

  1. They can use Node for server-side development and React for front-end code building without switching between frameworks and programming languages.

    And it saves resources, money, and time. The combination of Node.js and React can balance the high server requests and load when developers work on web app development.

  2. The deadly combination of React and Node create an organized web development process.

  3. After all, these technologies are scalable, effective, and fast. When working together, they can help you build high-functioning websites.

    Node with React enables the use of the total strength of JavaScript for building front-end and back-end codes.

    It gives more freedom and convenience when building websites or web apps, as you can use one language for every aspect. The popularity of these two technologies is increasing rapidly, and they will grow more in the future.

    Moreover, their demand has crossed Java. According to Statista, with 40.14% of respondents, React.js has acquired the first rank for the most used web app development framework.

    However, these two still haven’t built a powerful position for them.

    And new technologies are entering the development market. The combination of Node and React is an excellent option for developers who need to create responsive, modern web applications to manage a massive amount of data.

Add project files

Next, add four new files to your project.

  • Furthermore, React’s flexible design model provides users convenience and freedom to build reusable UI elements.
  • In contrast, Node’s event-driven structure enables them to deal with vast amounts of traffic more effectively.
  • Using the combination of React and Node.js for web app development can help you take your project to the next level.
  • You only need to hire experienced full stack developers to create appealing websites or web apps.

For this simple app, you add the new project files in the project root. For most apps, you add the files to subfolders and adjust relative path references accordingly.

  1. So, if you plan to combine React as a front-end with Node as a back-end for your next web development project, hire some dedicated and professional developers.

  2. In this tutorial, I will show you how to build full-stack React + Node.js + Express + MySQL example with a CRUD Application.

  3. The back-end server uses Node.js + Express for REST APIs, front-end side is a React.js client with React Router, Axios & Bootstrap.

  4. Related Posts: – React Redux + Node.js + Express + MySQL example: Build a CRUD App – React + Node.js Express: User Authentication with JWT example – React File Upload with Axios and Progress Bar to Rest API.

  5. Run both projects in one place:How to integrate React with Node.js Express on same Server/Port.

Add app code

  1. Dockerize: Docker Compose: React, Node.js, MySQL example. Node.js Express Back-endImplementation.

    React.js Front-endImplementation. We will build a full-stack Tutorial Application in that:. Tutorial has id, title, description, published status. User can create, retrieve, update, delete Tutorials. There is a search box for finding Tutorials by title.

  2. Here are screenshots of the example.

    – Show all items:. – Click on Edit button to view details of an item:.

  3. On this Page, you can:. change status to Published/Pending using Publish/UnPublished button.

    remove the object from MySQL Database using Delete button. update this object’s details on Database with Update button. – Search objects by field ‘title’:. – Check MySQL database:.

Configure webpack and TypeScript compiler options

Next, you add webpack configuration code to webpack-config.js. You add a simple webpack configuration that specifies an input file, app.tsx, and an output file, app-bundle.js, for bundling and transpiling JSX to plain JavaScript. For transpiling, you also configure some TypeScript compiler options. This basic configuration code is an introduction to webpack and the TypeScript compiler.

  1. We’re gonna build the application with following architecture:.

    – Node.js Express exports REST APIs & interacts with MySQL Database using Sequelize ORM.

  2. – React Client sends HTTP Requests and retrieves HTTP Responses using Axios, consume data on the components.

    React Router is used for navigating to pages.

  3. This is our React Node.js Express Sequelize application demo (with brief instruction) running with MySQL database.

Transpile the JSX

  1. These are APIs that Node.js Express App will export:. – db.config.js exports configuring parameters for MySQL connection & Sequelize.

  2. – Express web server in server.js where we configure CORS, initialize & run Express REST APIs.

    node_modules\.bin\webpack ./app.tsx --config webpack-config.js

    – Next, we add configuration for MySQL database in models/index.js, create Sequelize data model in models/tutorial.model.js.

    – Tutorial controller in controllers. – Routes for handling all CRUD operations (including custom finder) in tutorial.routes.js. If you want to use raw SQL (without Sequelize), kindly visit:Build Node.js Rest APIs with Express & MySQL.

    This backend works well with frontend in this tutorial. First, we create a folder:. Next, we initialize the Node.js App with a package.json file:. We need to install necessary modules: express, sequelize, mysql2 and cors.

  3. Run the command:. In the root folder, let’s create a new server.js file:.

  4. What we do are: – import express, and cors modules:.

    Express is for building the Rest apis. cors provides Express middleware to enable CORS with various options.

  5. – create an Express app, then add body-parser (json and urlencoded) and cors middlewares using app.use() method.

  6. Notice that we set origin: http://localhost:8081. – define a GET route which is simple for test.

Anytime you make changes to app.tsx, you must rerun the webpack command. To automate this step, you can add a build script to transpile the JSX.

Add a build script to transpile the JSX

Visual Studio versions starting with Visual Studio 2019 require a build script. Instead of transpiling JSX at the command line, as shown in the preceding section, you can transpile JSX when building from Visual Studio.

  1. – listen on port 8080 for incoming requests. Now let’s run the app with command: node server.js.

  2. Open your browser with url http://localhost:8080/, you will see:.

Run the app

  1. Yeah, the first step is done. We’re gonna work with Sequelize in the next section. In the app folder, we create a separate config folder for configuration with db.config.js file like this:.

    First five parameters are for MySQL connection.pool is optional, it will be used for Sequelize connection pool configuration:. max: maximum number of connection in pool. min: minimum number of connection in pool.

  2. idle: maximum time, in milliseconds, that a connection can be idle before being released.

    acquire: maximum time, in milliseconds, that pool will try to get connection before throwing error.

    For more details, please visit API Reference for the Sequelize constructor.

  3. We’re gonna initialize Sequelize in app/models folder that will contain model in the next step.

Set a breakpoint and run the app

Breakpoints are the most basic and essential feature of reliable debugging. A breakpoint indicates where Visual Studio should suspend your running code. You can then observe variable values, memory behavior, or whether a branch of code is running.

  1. Now create app/models/index.js with the following code:. Don’t forget to call sync() method in server.js:.

  2. In development, you may need to drop existing tables and re-sync database.

    Just use force: true as following code:. In models folder, create tutorial.model.js file like this:. This Sequelize Model represents tutorials table in MySQL database. These columns will be generated automatically: id, title, description, published, createdAt, updatedAt.

  3. After initializing Sequelize, we don’t need to write CRUD functions, Sequelize supports all of them:.

    create a new Tutorial: create(object). find a Tutorial by id: findByPk(id). get all Tutorials: findAll(). update a Tutorial by id: update(data, where: { id: id }).

  4. remove a Tutorial: destroy(where: { id: id }).

Set and hit a breakpoint in the client-side React code

In the preceding section, you attached the debugger to server-side Node.js code. To attach to and hit breakpoints in the client-side React code, you have to attach the debugger to the correct process. Here's one way to enable a browser and attach a process for debugging.

Enable the browser for debugging

remove all Tutorials: destroy(where: {}). find all Tutorials by title: findAll({ where: { title: .. These functions will be used in our Controller. We can improve the example by adding Comments for each Tutorial.

It is the One-to-Many Relationship and I write a tutorial for this at:Sequelize Associations: One-to-Many example – Node.js, MySQL. Or you can add Tags for each Tutorial and add Tutorials to Tag (Many-to-Many Relationship):Sequelize Many-to-Many Association example with Node.js & MySQL.

Inside app/controllers folder, let’s create tutorial.controller.js with these CRUD functions:.

  1. You can continue with step by step to implement this Node.js Express App in the post:Node.js Rest APIs example with Express, Sequelize & MySQL.

  2. Run our Node.js application with command: node server.js. The console shows:.

  3. – The App component is a container with React Router.

  4. It has navbar that links to routes paths. – TutorialsList component gets and displays Tutorials.

  5. – Tutorial component has form for editing Tutorial’s details based on :id.

  • – AddTutorial component has form for submission new Tutorial. – These Components call TutorialDataService methods which use axios to make HTTP requests and receive responses.

    msedge --remote-debugging-port=9222

    Or you can use React with Redux:.

    chrome.exe --remote-debugging-port=9222

More details at: React Redux CRUD App example with Rest API.

  1. react-router-dom 5.1.2. bootstrap 4.4.1.

    – package.json contains 4 main modules: react, react-router-dom, axios & bootstrap. – App is the container that has Router & navbar. – There are 3 components: TutorialsList, Tutorial, AddTutorial.

  2. – http-common.js initializes axios with HTTP base Url and headers.

    – TutorialDataService has methods for sending HTTP requests to the Apis. – .env configures port for this React CRUD App.

    chrome.exe --remote-debugging-port=9222

The browser starts with debugging enabled. The app isn't running yet, so the browser page is empty.

Attach the debugger to client-side script

  1. For React Hooks version, kindly visit this tutorial. For Typescript version:.

    • Please visit:React Typescript CRUD example with Web API. Open cmd at the folder you want to save Project folder, run command:npx create-react-app react-crud. After the process is done. We create additional folders and files like the following tree:.

    • add-tutorial.component.js. tutorial.component.js. tutorials-list.component.js. tutorial.service.js. Run command: npm install bootstrap.

      Open src/App.js and modify the code inside it as following-. – Run the command: npm install react-router-dom.

      – Open src/index.js and wrap App component by BrowserRouter object.

      Open src/App.js, this App component is the root container for our application, it will contain a navbar, and also, a Switch object with several Route.

      Each Route points to a React Component. Let’s install axios with command: npm install axios. Under src folder, we create http-common.js file with following code:. You can change the baseURL that depends on REST APIs url that your Server configures. In this step, we’re gonna create a service that uses axios object above to send HTTP requests. We call axios get, post, put, delete method corresponding to HTTP Requests: GET, POST, PUT, DELETE to make CRUD Operations.

  2. Now we’re gonna build 3 components corresponding to 3 Routes defined before. You can continue with step by step to implement this React App in the post: – React.js CRUD example to consume Web API – or React Hooks CRUD example to consume Web API.

    Using React with Redux: – React Redux CRUD example with Rest API – React Hooks + Redux: CRUD example with Rest API.

    For Typescript version:React Typescript CRUD example to consume Web API.

  3. You can run our App with command: npm start. If the process is successful, open Browser with Url: http://localhost:8081/ and check it.

    You can find Github source code for this tutorial at: React + Node App Github.

    Today we have an overview of React.js + Node.js Express + MySQL example when building a full-stack CRUD App. We also take a look at client-server architecture for REST API using Express & Sequelize ORM, as well as React.js project structure for building a front-end app to make HTTP requests and consume responses.

  4. Next tutorials show you more details about how to implement the system (including source code): – Back-end:.

    You will want to know how to run both projects in one place:How to integrate React with Node.js Express on same Server/Port. With Pagination:React Pagination with API using Material-UI.

    Or Serverless with Firebase: – React Firebase CRUD with Realtime Database – React Firestore CRUD App example | Firebase Cloud Firestore.

  5. Happy learning, see you again! Dockerize: Docker Compose: React, Node.js, MySQL example. By Manish Patel | Wednesday, July 22, 2020 01:09 PM | 5min read.

  6. Are you planning on developing an app or a website?

    Then the biggest challenge you will face is a difference in frameworks.

    It is often an issue of different syntax at the backend and frontend framework. Here, JavaScript can help you with two frameworks for your full-stack development plans.

    One is Nodejs and the other is ReactJs.

    Among many of the frameworks in JavaScript, Node.js is quite popular. According to the Stack Overflow report, Node.js is preferred by 49.9% of developers. So, it is natural to choose the framework for your project. But, when you are selecting a front-end development framework, React.Js becomes obvious.

  7. Because it is also based on JavaScript and that is why there is no gap of syntax. Let’s take an example of website development through a combination of Node.js with React.Js.

    The first step toward app development is to create a project directory. You can create one on your terminal. Create one through these codes. mkdir my_awesome_project. cd my_awesome_project.

    Next, we will create a front-end React.Js app. React.Js is a Javascript library created by Facebook. So, you can just get to GitHub and choose to create-react-app for your React.Js app. npx create-react-app client. You can use npx for the creation of a React.Js app easily. If you don’t have enough technical knowledge then you can get professional React.Js development in India.

    • Npx is a tool created for the developers to extend the modules from the npm registry. It can help developers to use CLI tools and executables of the registry.

      • Next, you need to change the terminal directory into the client directory and start the app. Navigate the http://localhost:3000 URL in your browser and congratulations there you are with a basic React.Js app.

      • Now let’s create a Node.js app. Here, we will use Express.Js. It is a minimalist framework based on the Node.js framework. It enables faster development and provides excellent features.

      We will create the app through the Express app generator. You can use the following code for executing the app. npx express-generator API.

    • Express generator from the npm’s npx- we all know npm as the Node Package Manager.

Next steps