Debugging Node.js Applications with Visual Studio Code
5 mins read

By: vishwesh

Debugging Node.js Applications with Visual Studio Code

Debugging is an essential part of the development process, especially when working with real-time applications like Node.js applications. Visual Studio Code (VS Code) is a popular and powerful code editor that provides excellent debugging capabilities for Node.js applications. In this article, we will explore how to debug Node.js applications effectively using VS Code. Whether you are a beginner or an experienced developer, this guide will help you gain a better understanding of the debugging process.


Before we dive into debugging applications, make sure you have the following prerequisites installed:

  1. Node.js: You can download and install Node.js from the official website (
  2. Visual Studio Code: VS Code is a free, lightweight, and extensible code editor available for Windows, macOS, and Linux. You can download it from the official website (

Setting Up a Application

To demonstrate the debugging process, let's create a simple chat application. Follow the steps below to set up the application:

  1. Create a new directory for your project and navigate to it in your terminal.
  2. Initialize a new Node.js project by running the command npm init -y in the terminal. This will generate a package.json file for your project.
  3. Install the package by running npm install
  4. Create a new file named index.js and open it in VS Code.
  5. In index.js, require the module and create a new HTTP server instance:

javascriptCopy code

const http = require``(``'http'``); const socketIO = require``(``''``); const server = http.``createServer``(); const io = socketIO``(server); // Rest of the code goes here...

  1. Set up the connection event to handle incoming connections and emit/receive messages:
io.on('connection', (socket) => {
  console.log('A user connected');

  socket.on('chat message', (message) => {
    console.log('Received message:', message);
    io.emit('chat message', message);

  socket.on('disconnect', () => {
    console.log('A user disconnected');
  1. Start the server by adding the following code at the end of index.js:
const port = 3000;
server.listen(port, () => {
  console.log(`Server listening on port ${port}`);

Setting Up Debugging in Visual Studio Code

Now that our application is set up, let's configure VS Code to enable debugging:

  1. Open your project in VS Code.
  2. Click on the debug icon in the sidebar (or use the shortcut Ctrl+Shift+D).
  3. Click on the gear icon to create a new launch.json file.
  4. Select "Node.js" as the environment.
  5. Update the generated launch.json file with the following configuration:
  "type": "node",
  "request": "launch",
  "name": "Debug",
  "program": "${workspaceFolder}/index.js",
  "runtimeArgs": [
  "skipFiles": [
  1. Save the launch.json file.

Starting the Debugger

With the debugging configuration in place, let's start the debugger:

  1. Make sure your server is not already running.
  2. Click on the green play button in the debug sidebar (or use the shortcut F5).
  3. VS Code will start the debugger and run your application.
  4. You should see a message in the debug console indicating that the debugger is attached and the server is running.

Setting Breakpoints

Breakpoints allow you to pause the execution of your code at specific points to inspect variables, step through the code, and identify issues. Let's set breakpoints in our application:

  1. Open the index.js file in VS Code.
  2. Navigate to the line where you want to set a breakpoint (e.g., inside the connection event).
  3. Click on the area to the left of the line number, and you will see a red dot indicating that a breakpoint has been set.
  4. Repeat this process to set breakpoints in other parts of the code that you want to examine during debugging.

Debugging Application

Now that we have set up breakpoints, let's see how we can debug our application:

  1. Start the debugger as explained earlier.
  2. Open a browser and visit http://localhost:3000 to connect to the server.
  3. Perform actions in your application that trigger the code where you set breakpoints.
  4. When the execution reaches a breakpoint, the debugger will pause, and you can inspect the application's state.
  5. Use the various debugging controls provided by VS Code to navigate through the code, step over, step into, or step out of function calls.
  6. You can hover over variables to see their values, add watches to track specific variables, and interact with the debug console to execute code snippets.
  7. Continue stepping through the code and inspecting variables until you identify and resolve any issues.


In this article, we explored how to effectively debug Node.js applications using Visual Studio Code. We started by setting up a chat application and then configured the debugger in VS Code. We learned how to set breakpoints and step through the code to inspect variables and identify problems. Debugging is a valuable skill for developers, and with the powerful debugging capabilities of VS Code, you can efficiently diagnose and fix issues in your applications. By mastering the debugging process, you'll become a more confident and proficient developer in building real-time applications.

Remember, debugging is not only about fixing errors but also about understanding your code better and improving its performance. So, keep practicing and experimenting with the debugging features provided by VS Code to become a more proficient developer.

Happy debugging!

Recent posts

Don't miss the latest trends

    Popular Posts

    Popular Categories