The Complete Guide to Installing Node.js on Ubuntu with NVM: Everything You Need to Know

📖 Estimated Reading Time: 12 minutes
🎯 Skill Level: Beginner to Intermediate
💻 Prerequisites: Ubuntu system with terminal access and internet connection
📅 Last Updated: September 11, 2025

The Complete Guide to Installing Node.js on Ubuntu with NVM: Everything You Need to Know

⚡ Quick Answer

The fastest way to install Node.js on Ubuntu: Use NVM (Node Version Manager) with these commands: curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash, then nvm install --lts. This gives you version flexibility, no sudo requirements, and proper package management.

Node.js has revolutionized server-side JavaScript development, powering millions of applications worldwide. If you’re developing on Ubuntu, choosing the right installation method can make or break your development experience. While there are several ways to install Node.js, using Node Version Manager (NVM) stands out as the most flexible and developer-friendly approach.

In this comprehensive guide, we’ll walk you through everything you need to know about installing Node.js using NVM, from basic installation to advanced version management techniques that will streamline your development workflow.

1. Understanding Node.js and Its Ecosystem

What is Node.js?

Node.js is a JavaScript runtime built on Chrome’s V8 JavaScript engine that allows you to run JavaScript on the server side. Unlike traditional server-side languages, Node.js uses an event-driven, non-blocking I/O model that makes it lightweight and efficient for data-intensive real-time applications.

Key Node.js Features:

Asynchronous and Event-Driven: All APIs are asynchronous and non-blocking, enabling high concurrency
Fast Execution: Built on Google Chrome’s V8 JavaScript Engine for optimal performance
Single-Threaded: Uses a single-threaded model with event looping for efficiency
Cross-Platform: Runs on Windows, Linux, Unix, Mac OS X, and more
Open Source: Large community support and continuous development

The npm Ecosystem

Node.js comes bundled with npm (Node Package Manager), the world’s largest software registry. With over 1.5 million packages, npm provides access to an enormous ecosystem of libraries and tools that can accelerate your development process. From popular frameworks like React and Express to utility libraries and development tools, npm is your gateway to the JavaScript ecosystem.

2. Why NVM is the Superior Installation Method

Problems with Traditional Installation Methods

Before diving into NVM, let’s understand why traditional installation methods fall short for serious development work:

1. APT Package Manager Issues

Ubuntu’s default package manager often contains outdated versions of Node.js. The rapid development cycle of Node.js means that by the time a version makes it into Ubuntu’s repositories, newer versions with important updates and security patches are already available.

# This often installs an outdated version
sudo apt install nodejs npm

# Check version - often disappointing
node --version
# Output might be: v12.22.9 (while latest LTS is v18.x)

⚠️ APT Installation Problems

Outdated versions (sometimes 2-3 major versions behind)
Binary name conflicts (node vs nodejs)
Permission issues with global packages
Difficult to upgrade to newer versions

2. Official Binary Installation Problems

While downloading binaries from the official Node.js website gives you the latest version, this method has several significant drawbacks that become apparent in real-world development scenarios:

Manual updates required: No automatic update mechanism
Difficult to switch between versions: Different projects need different Node.js versions
Potential conflicts with system packages: Can interfere with Ubuntu’s package management
Complex uninstallation process: Manual removal of files and PATH modifications

3. Snap Package Limitations

Snap packages, while convenient, can have permission issues and may not integrate well with development tools that expect Node.js to be installed in traditional locations. This can cause problems with IDE integration and build tools.

NVM Advantages in Detail

Node Version Manager (NVM) solves all these problems elegantly while providing additional benefits that make development more productive and less frustrating.

1. Multiple Version Management

Different projects often require different Node.js versions. Legacy applications might need older versions for compatibility, while new projects benefit from the latest features. This is extremely common in professional development environments where you might maintain several applications simultaneously.

💡 Real-World Scenario

Imagine you’re maintaining a legacy e-commerce site on Node.js 14, developing a new React app that requires Node.js 18, and experimenting with features that need the latest Node.js 19. With traditional installation methods, this would be a nightmare. With NVM, it’s effortless.

NVM allows you to:

Install multiple Node.js versions simultaneously without conflicts
Switch between versions instantly with a single command
Set different default versions for different projects
Test your applications across multiple Node.js versions for compatibility

2. Easy Updates and Rollbacks

With NVM, updating to a new Node.js version is as simple as running one command. If issues arise with a new version, rolling back is equally straightforward. This safety net encourages experimentation with newer versions while maintaining stability for production work.

3. No Sudo Required

NVM installs Node.js in your user directory, eliminating the need for administrator privileges. This approach reduces security risks and prevents the common npm permission issues that plague global package installations with system-wide Node.js installations.

4. Automatic npm Management

Each Node.js version installed through NVM comes with its own npm version, preventing conflicts between global packages. This isolation ensures that global packages installed for one Node.js version don’t interfere with another version’s packages.

3. Detailed Installation Process

Prerequisites and System Preparation

Before installing NVM, ensure your Ubuntu system is properly prepared. This preparation step prevents common installation issues and ensures a smooth setup process.

📋 Prerequisites Checklist

☑️ Ubuntu 18.04 or later (or compatible Linux distribution)
☑️ Terminal access with bash or zsh shell
☑️ Internet connection for downloading packages
☑️ curl or wget installed (usually pre-installed)

Step 1: Update Your System

Start by updating your package lists and installed packages to ensure you have the latest security patches and system components.

# Update package lists and installed packages
sudo apt update && sudo apt upgrade -y

# Verify system is up to date
sudo apt list --upgradable

Step 2: Install Essential Build Tools

Many Node.js packages include native dependencies that require compilation. Installing build tools now prevents issues later when installing packages with native modules.

# Install essential development tools
sudo apt install build-essential libssl-dev curl git -y

# Verify installation
gcc --version
curl --version

Step 3: Remove Existing Node.js Installations

If you have Node.js installed through other methods, remove them to prevent conflicts. This step is crucial for a clean NVM installation.

# Remove Node.js installed via apt
sudo apt remove nodejs npm -y
sudo apt autoremove -y

# Remove any global npm packages directory
sudo rm -rf /usr/local/lib/node_modules

# Remove Node.js binaries
sudo rm -rf /usr/local/bin/node
sudo rm -rf /usr/local/bin/npm
sudo rm -rf /usr/local/bin/npx

# Clean up any remaining references
hash -d node 2>/dev/null || true
hash -d npm 2>/dev/null || true

Installing NVM (Extended Process)

The NVM installation process downloads and executes a shell script that sets up the version manager. This script performs several important configuration steps automatically.

Installation Command: This downloads and runs the official NVM installation script

# Download and install NVM (latest version)
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash

# Alternative using wget if curl isn't available
wget -qO- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash

What This Installation Script Does

Understanding what happens during installation helps you troubleshoot issues and verify successful setup:

Downloads the script: Fetches the latest installation script from the official GitHub repository
Creates NVM directory: Sets up ~/.nvm directory structure in your home folder
Clones repository: Downloads the complete NVM codebase for version management functionality
Updates shell profile: Automatically adds NVM initialization to your shell configuration file

💡 Manual Verification Process

After installation, verify the setup was successful:

# Check if NVM directory exists
ls -la ~/.nvm

# View the added lines in your shell profile
tail -5 ~/.bashrc

# Expected output should include:
# export NVM_DIR="$HOME/.nvm"
# [ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"
# [ -s "$NVM_DIR/bash_completion" ] && \. "$NVM_DIR/bash_completion"

Activating NVM

After installation, NVM needs to be loaded into your current shell session. The installation script adds the necessary lines to your shell profile, but you need to reload it for the current session.

# Reload your shell profile (for bash)
source ~/.bashrc

# If you're using zsh
source ~/.zshrc

# Alternative: start a new terminal session
# You can also close and reopen your terminal

Verification Commands

Confirm NVM is properly loaded and functional with these verification steps:

# Check NVM version
nvm --version
# Expected output: 0.39.0 (or latest version)

# List available NVM commands
nvm --help

# Verify NVM function is available
type nvm
# Expected output: nvm is a shell function

⚠️ Troubleshooting: “nvm: command not found”

If you see this error, try these solutions:

Restart your terminal or run source ~/.bashrc
Check if the installation modified your shell profile: grep -n "NVM_DIR" ~/.bashrc
Manually add NVM to your profile if missing
Ensure you’re using bash or zsh (NVM doesn’t work with all shells)

4. Installing Node.js Versions

Understanding LTS vs Current Releases

Before installing Node.js, it’s important to understand the difference between release types. Node.js follows a predictable release schedule with two main types of versions:

Release Type	Description	Best For	Support Duration
LTS (Long-Term Support)	Stable versions with extended support	Production applications	30 months
Current	Latest features, may have breaking changes	Development and testing	6 months

Installing Your First Node.js Version

For most users, starting with the latest LTS version is the best choice. LTS versions provide stability while including recent features and security updates.

Recommended First Installation: Install latest LTS version for stability

# Install the latest LTS version
nvm install --lts

# This will:
# 1. Download the latest LTS Node.js version
# 2. Install it in ~/.nvm/versions/node/
# 3. Automatically switch to use this version
# 4. Install the corresponding npm version

# Verify installation
node --version
npm --version

Installing Specific Versions

Different projects may require specific Node.js versions. Here’s how to install and manage multiple versions:

# Install specific versions
nvm install 18.18.2    # Specific patch version
nvm install 16.20.2    # Different major version
nvm install 14.21.3    # Legacy version for older projects

# Install latest of a major version
nvm install 18         # Latest Node.js 18.x
nvm install 16         # Latest Node.js 16.x

# Install the absolute latest version (Current release)
nvm install node       # "node" is an alias for latest

Exploring Available Versions

NVM provides several commands to explore what versions are available for installation:

# List all available versions (this will be a very long list!)
nvm list-remote

# List only LTS versions
nvm list-remote --lts

# Search for specific major versions
nvm list-remote | grep "v18\."
nvm list-remote | grep "v16\."

# List installed versions on your system
nvm list

💡 Pro Tip: Named LTS Releases

Node.js LTS versions have codenames. You can install by codename:

# Install by LTS codename
nvm install lts/hydrogen    # Node.js 18.x LTS
nvm install lts/gallium     # Node.js 16.x LTS  
nvm install lts/fermium     # Node.js 14.x LTS

# Use codenames in aliases too
nvm alias production lts/hydrogen
nvm alias legacy lts/fermium

5. Advanced Version Management

Switching Between Versions

One of NVM’s most powerful features is the ability to instantly switch between Node.js versions. This is essential when working on multiple projects with different requirements.

# Switch to a specific version
nvm use 18.18.2

# Switch to latest LTS
nvm use --lts

# Switch to latest current
nvm use node

# Switch using an alias (we'll create these next)
nvm use production

Creating and Managing Aliases

Aliases make version management more intuitive by giving meaningful names to specific versions. This is particularly useful in team environments where everyone needs to use the same versions for different project types.

# Set default version for new terminal sessions
nvm alias default 18.18.2

# Create project-specific aliases
nvm alias production 18.18.2
nvm alias development 19.0.0
nvm alias legacy 14.21.3
nvm alias testing 16.20.2

# List all aliases
nvm alias

# Remove an alias
nvm unalias testing

Project-Specific Version Management

The most professional way to manage Node.js versions is using .nvmrc files in your project directories. This ensures everyone on your team uses the same Node.js version, preventing “works on my machine” problems.

Best Practice: Create .nvmrc files for all projects

# Navigate to your project directory
cd ~/my-awesome-project

# Create .nvmrc file specifying the required version
echo "18.18.2" > .nvmrc

# Now anyone can use the specified version
nvm use
# Output: Found '/home/user/my-awesome-project/.nvmrc' with version <18.18.2>
# Now using node v18.18.2

# Install the version if not already available
nvm install
# This reads .nvmrc and installs if needed

💡 Advanced .nvmrc Usage

You can use version ranges and aliases in .nvmrc files:

# Different .nvmrc content options
echo "lts/*" > .nvmrc          # Latest LTS
echo "18" > .nvmrc             # Latest 18.x
echo ">=16.0.0" > .nvmrc       # Minimum version requirement
echo "lts/hydrogen" > .nvmrc   # Specific LTS codename

Automatic Version Switching

For the ultimate convenience, you can set up automatic version switching that reads .nvmrc files when you change directories. This ensures you’re always using the correct Node.js version for each project.

# Add this function to your ~/.bashrc or ~/.zshrc
# Automatic version switching when cd into directories

cdnvm() {
    command cd "$@";
    nvm_path=$(nvm_find_up .nvmrc | tr -d '\n')

    # If there are no .nvmrc file, use the default nvm version
    if [[ ! $nvm_path = *[^[:space:]]* ]]; then
        declare default_version;
        default_version=$(nvm version default);

        # If there is no default version, set it to `node`
        if [[ $default_version == "N/A" ]]; then
            nvm alias default node;
            default_version=$(nvm version default);
        fi

        # If the current version is not the default version, set it to use the default version
        if [[ $(nvm current) != "$default_version" ]]; then
            nvm use default;
        fi
    elif [[ -s $nvm_path/.nvmrc && -r $nvm_path/.nvmrc ]]; then
        declare nvm_version
        nvm_version=$(<"$nvm_path"/.nvmrc)

        declare locally_resolved_nvm_version
        locally_resolved_nvm_version=$(nvm ls --no-colors "$nvm_version" | tail -1 | tr -d '->*' | tr -d '[:space:]')

        # If it is not already installed, install it
        if [[ "$locally_resolved_nvm_version" == "N/A" ]]; then
            nvm install "$nvm_version";
        elif [[ $(nvm current) != "$locally_resolved_nvm_version" ]]; then
            nvm use "$nvm_version";
        fi
    fi
}

# Replace the default cd command
alias cd='cdnvm'

# Initialize for current directory
cd "$PWD"

⚠️ Shell Function Setup

After adding the automatic switching function:

Restart your terminal or run source ~/.bashrc
Test by creating a project with .nvmrc and navigating to it
The function only works with bash/zsh – not all shells support this

6. Comprehensive Installation Verification

After installation, it’s crucial to verify everything is working correctly. This comprehensive verification process ensures your development environment is properly set up.

Basic Version Checks

# Check Node.js version
node --version
# Expected output: v18.18.2 (or your installed version)

# Check npm version  
npm --version
# Expected output: 9.8.1 (or corresponding npm version)

# Check npx version (Node.js package runner)
npx --version
# Expected output: 9.8.1 (same as npm usually)

# Verify installation paths
which node
which npm
# Should point to ~/.nvm/versions/node/...

Test Node.js Functionality

Create a comprehensive test to verify Node.js is functioning correctly with all its core features:

# Create a comprehensive test file
cat > test-node.js << 'EOF'
console.log('=== Node.js Installation Test ===');
console.log('Node.js version:', process.version);
console.log('npm version:', process.env.npm_version || 'Not available');
console.log('Platform:', process.platform);
console.log('Architecture:', process.arch);
console.log('Node.js executable path:', process.execPath);

// Test async functionality
console.log('\n=== Testing Async Operations ===');
setTimeout(() => {
    console.log('✓ setTimeout working');
}, 100);

// Test Promise support
Promise.resolve('Promise resolved').then(msg => {
    console.log('✓', msg);
});

// Test modern JavaScript features
const testArrowFunction = () => console.log('✓ Arrow functions working');
testArrowFunction();

// Test module system
const fs = require('fs');
console.log('✓ CommonJS modules working');

console.log('\n=== Test Complete ===');
EOF

# Run the test
node test-node.js

# Clean up test file
rm test-node.js

Test npm Functionality

Verify npm is working correctly by testing package installation and global package management:

# Test npm by installing a simple global package
npm install -g cowsay

# Test the installed package
cowsay "Node.js is working perfectly!"

# Verify global package location
npm list -g --depth=0

# Test local package installation
mkdir test-npm && cd test-npm
npm init -y
npm install lodash
node -e "console.log('Lodash loaded:', require('lodash').VERSION)"

# Clean up
cd .. && rm -rf test-npm
npm uninstall -g cowsay

7. Advanced NVM Usage and Best Practices

Managing Global Packages Across Versions

One challenge with multiple Node.js versions is managing global packages efficiently. Each Node.js version has its own global package space, which provides isolation but can require reinstalling packages when switching versions.

Smart Migration: Transfer global packages when installing new versions

# Install a new version and migrate global packages from current version
nvm install 18.18.2 --reinstall-packages-from=16.20.2

# Or migrate from currently active version
nvm install 19.0.0 --reinstall-packages-from=current

# List global packages for current version
npm list -g --depth=0

# Common global packages for development
npm install -g typescript eslint prettier nodemon pm2 @angular/cli create-react-app

Creating Global Package Management Scripts

Automate global package installation for consistency across Node.js versions:

# Create global packages list
cat > ~/.nvm/default-packages << 'EOF'
typescript
eslint
prettier
nodemon
pm2
create-react-app
@angular/cli
@vue/cli
http-server
live-server
EOF

# Install packages from list (NVM will automatically use this file)
# When installing new Node.js versions with --reinstall-packages-from

💡 Pro Tip: default-packages File

NVM automatically reads ~/.nvm/default-packages when installing new Node.js versions. Any packages listed in this file will be automatically installed globally with each new Node.js version.

Performance Optimization

Enable Faster Downloads

Optimize NVM performance by configuring mirrors and caching options:

# Set environment variables for faster installation
echo 'export NVM_NODEJS_ORG_MIRROR=https://nodejs.org/dist' >> ~/.bashrc
echo 'export NVM_IOJS_ORG_MIRROR=https://iojs.org/dist' >> ~/.bashrc

# For users with slow connections or in certain regions
# echo 'export NVM_NODEJS_ORG_MIRROR=https://npm.taobao.org/mirrors/node' >> ~/.bashrc

# Reload configuration
source ~/.bashrc

Lazy Loading for Faster Shell Startup

If your shell startup becomes slow due to NVM, implement lazy loading:

# Add to ~/.bashrc for lazy loading (advanced users only)
# This loads NVM only when needed, speeding up shell startup

nvm() {
    unset -f nvm node npm
    export NVM_DIR="$HOME/.nvm"
    [ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"
    [ -s "$NVM_DIR/bash_completion" ] && \. "$NVM_DIR/bash_completion"
    nvm "$@"
}

node() {
    unset -f nvm node npm
    export NVM_DIR="$HOME/.nvm"
    [ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"
    node "$@"
}

npm() {
    unset -f nvm node npm
    export NVM_DIR="$HOME/.nvm"
    [ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"
    npm "$@"
}

⚠️ Lazy Loading Considerations

Only use if you experience slow shell startup times
May cause slight delays on first use of node/npm commands
Not compatible with automatic version switching scripts
Test thoroughly before implementing in production environments

8. Comprehensive Troubleshooting Guide

Common Installation Issues

Issue 1: "nvm: command not found"

Symptoms: After installation, NVM commands don't work in new terminal sessions.

Diagnostic Steps:

# Step 1: Check if NVM directory exists
ls -la ~/.nvm
# Should show nvm.sh and other files

# Step 2: Check if shell profile was modified
grep -n "NVM_DIR" ~/.bashrc
# Should show export NVM_DIR and related lines

# Step 3: Check current shell
echo $SHELL
# Should be /bin/bash or /bin/zsh

# Step 4: Manually load NVM
export NVM_DIR="$HOME/.nvm"
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"
nvm --version

Solutions in order of preference:

# Solution 1: Reload shell profile
source ~/.bashrc

# Solution 2: Restart terminal completely
# Close and reopen your terminal application

# Solution 3: Manually add NVM to profile (if missing)
echo 'export NVM_DIR="$HOME/.nvm"' >> ~/.bashrc
echo '[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"' >> ~/.bashrc
echo '[ -s "$NVM_DIR/bash_completion" ] && \. "$NVM_DIR/bash_completion"' >> ~/.bashrc
source ~/.bashrc

# Solution 4: Reinstall NVM completely
rm -rf ~/.nvm
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash

Issue 2: Permission Denied Errors

Symptoms: Getting permission errors during Node.js or package installation.

⚠️ Never Use Sudo with NVM

If you're getting permission errors with NVM commands, never use sudo. This defeats the purpose of NVM and will cause more problems.

# Fix permissions on NVM directory
sudo chown -R $(whoami) ~/.nvm

# Fix npm directory permissions
sudo chown -R $(whoami) ~/.npm

# If you previously used sudo with npm, clean up
sudo rm -rf ~/.npm/_cacache
npm cache clean --force

# Verify correct ownership
ls -la ~/.nvm
ls -la ~/.npm

Issue 3: Network/Proxy Issues

Symptoms: Downloads fail, timeout during installation, or slow download speeds.

# For corporate networks, configure proxy
npm config set proxy http://your-proxy-server:port
npm config set https-proxy http://your-proxy-server:port

# For SSL certificate issues (use temporarily)
npm config set strict-ssl false
# Warning: Only use this temporarily and for testing

# Reset npm configuration if needed
npm config delete proxy
npm config delete https-proxy
npm config set strict-ssl true

# Use alternative installation method
wget -qO- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash

Runtime Issues

Issue 4: Wrong Node.js Version Being Used

Symptoms: Different Node.js version being used despite setting it with NVM.

# Diagnostic commands
which node
node --version
nvm current
nvm list

# Check PATH variable for conflicts
echo $PATH | tr ':' '\n' | grep -E "(node|nvm)"

# Common solutions
nvm use default
nvm use $(cat .nvmrc) # if using .nvmrc

# Check for system Node.js interference
dpkg -l | grep -i node
snap list | grep node

# Remove system Node.js if conflicting
sudo apt remove nodejs npm
sudo snap remove node

Issue 5: Global Package Problems

Symptoms: Global packages not working or conflicts between versions.

# Check global package configuration
npm config get prefix
# Should be something like: /home/username/.nvm/versions/node/v18.18.2

# Fix global package prefix if wrong
npm config set prefix $(npm config get globaldir)

# List and reinstall global packages
npm list -g --depth=0
npm install -g $(npm list -g --parseable --depth=0 | xargs basename | grep -v npm)

9. Security Best Practices

Keeping Node.js Secure

Security should be a primary concern in any development environment. Node.js security involves keeping the runtime updated, managing packages securely, and following secure coding practices.

Regular Security Updates

# Check for security updates
npm audit

# View detailed security report
npm audit --audit-level high

# Update npm itself to latest version
npm install -g npm@latest

# Update global packages
npm update -g

# Check Node.js security releases
nvm list-remote --lts | head -10

Package Security Management

# Install security audit tools
npm install -g npm-audit-resolver
npm install -g depcheck
npm install -g nsp

# Audit project dependencies
npm audit --audit-level high

# Fix vulnerabilities automatically (be careful in production)
npm audit fix

# Manual review of high-severity issues
npm audit fix --force

⚠️ Security Update Strategy

LTS versions: Apply security updates immediately
Dependencies: Review audit reports weekly
Global packages: Keep minimal and updated
Production: Test security updates in staging first

Environment Isolation

Use NVM's version isolation to create secure, separated environments for different projects:

# Create isolated environments for different project types
mkdir -p ~/projects/{legacy,current,experimental}

# Legacy projects (Node.js 14)
cd ~/projects/legacy
echo "14.21.3" > .nvmrc
nvm use

# Current production projects (Node.js 18 LTS)
cd ~/projects/current
echo "18.18.2" > .nvmrc
nvm use

# Experimental projects (latest version)
cd ~/projects/experimental
echo "node" > .nvmrc
nvm use

10. Integration with Development Tools

IDE Integration

Modern IDEs need to be configured to work seamlessly with NVM-managed Node.js installations. Here's how to configure popular development environments:

Visual Studio Code

Configure VS Code to use NVM-managed Node.js and properly load your shell environment:

# Create VS Code settings for NVM integration
# Add to .vscode/settings.json in your workspace:
{
    "terminal.integrated.profiles.linux": {
        "bash": {
            "path": "bash",
            "args": ["-l"]
        }
    },
    "terminal.integrated.defaultProfile.linux": "bash",
    "typescript.preferences.includePackageJsonAutoImports": "auto",
    "eslint.nodeEnv": "development"
}

WebStorm/IntelliJ IDEA

Configure JetBrains IDEs to use the correct Node.js installation:

Configuration Steps:

1. Go to File → Settings → Languages & Frameworks → Node.js and npm

2. Set Node interpreter to: ~/.nvm/versions/node/v18.18.2/bin/node

3. Set Package manager to: ~/.nvm/versions/node/v18.18.2/bin/npm

4. Enable "Coding assistance for Node.js"

Shell Integration Enhancements

Enhanced Prompt Display

Add Node.js version information to your shell prompt for better visibility:

# Add to ~/.bashrc for Node.js version in prompt
# Add this function to show current Node.js version
nvm_prompt_info() {
    [[ -f "$NVM_DIR/nvm.sh" ]] || return
    local nvm_current=$(nvm current 2>/dev/null)
    [[ $nvm_current == "system" ]] && return
    echo " ⬢ ${nvm_current}"
}

# Modify your PS1 prompt
export PS1='[\u@\h \W$(nvm_prompt_info)]\$ '

Advanced Tab Completion

# Enable enhanced tab completion for NVM
# This should be automatically added by NVM installation
[ -s "$NVM_DIR/bash_completion" ] && \. "$NVM_DIR/bash_completion"

# Test tab completion
nvm use   # Should show available versions

11. Maintenance and Updates

Keeping NVM Updated

Regular maintenance ensures your development environment stays current and secure. NVM itself should be updated periodically to get new features and bug fixes.

# Update NVM to latest version
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash
source ~/.bashrc

# Check NVM version after update
nvm --version

# Update to latest LTS Node.js and migrate packages
nvm install --lts --reinstall-packages-from=current
nvm alias default lts/*

Cleanup and Maintenance

Regular cleanup prevents your system from accumulating outdated versions and unnecessary files:

# List all installed versions
nvm list

# Remove old versions you no longer need
nvm uninstall 14.21.3
nvm uninstall 16.18.0

# Clear npm cache to free disk space
npm cache clean --force

# Clear NVM download cache
rm -rf ~/.nvm/.cache

# Remove unused global packages
npm list -g --depth=0 --parseable | grep -v npm | xargs dirname | xargs basename | sort -u

💡 Maintenance Schedule Recommendations

Weekly: Check for Node.js security updates
Monthly: Update global packages and clean cache
Quarterly: Review and remove unused Node.js versions
Semi-annually: Update NVM itself and review global packages

Frequently Asked Questions

❓ How do I completely uninstall NVM and start over?

Answer: Remove the NVM directory and clean your shell profile, then reinstall:

# Remove NVM directory
rm -rf ~/.nvm

# Remove NVM lines from shell profile
sed -i '/NVM_DIR/d' ~/.bashrc
sed -i '/nvm.sh/d' ~/.bashrc

# Restart terminal and reinstall
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash

❓ Why can't I install packages globally without permission errors?

Answer: This usually means you're using system Node.js instead of NVM-managed Node.js. Verify you're using NVM's version:

# Check which Node.js you're using
which node
# Should point to ~/.nvm/versions/node/...

# If not, switch to NVM version
nvm use default

# Install global packages without sudo
npm install -g package-name

❓ How do I use different Node.js versions in different terminal tabs?

Answer: Each terminal session maintains its own NVM version. Use nvm use in each tab:

# Terminal tab 1 - Legacy project
nvm use 14.21.3

# Terminal tab 2 - Current project  
nvm use 18.18.2

# Terminal tab 3 - Latest features
nvm use node

❓ What should I do if npm audit shows vulnerabilities?

Answer: Evaluate the severity and fix appropriately. Don't automatically run npm audit fix --force in production:

# Check vulnerability details
npm audit

# Fix non-breaking changes
npm audit fix

# For breaking changes, update manually
npm update package-name

# As last resort (test thoroughly)
npm audit fix --force

❓ Can I use NVM in production environments?

Answer: While possible, it's generally not recommended. Use NVM for development and testing, but prefer direct Node.js installation or containerization for production:

Production Alternatives:

• Direct Node.js installation from NodeSource repository

• Docker containers with specific Node.js versions

• Cloud platform managed Node.js environments

• Binary releases for predictable deployments

Conclusion

Installing Node.js with NVM on Ubuntu provides unmatched flexibility for JavaScript development. This approach solves version management challenges, eliminates permission issues, and creates a professional development environment that scales with your needs.

Key takeaways from this guide:

NVM provides superior version management compared to traditional installation methods, enabling seamless switching between Node.js versions
Project-specific versions ensure consistency across development environments using .nvmrc files
Regular maintenance keeps your development environment secure and up-to-date with latest Node.js releases
Proper IDE integration enhances productivity by ensuring development tools work seamlessly with NVM-managed installations
Security best practices include regular auditing, timely updates, and isolated project environments

Whether you're building web applications, APIs, command-line tools, or exploring the latest JavaScript features, NVM provides the foundation for a robust and flexible development environment. The investment in learning NVM pays dividends in reduced configuration issues, easier project onboarding, and more efficient development workflows.

Pro Tip: Create a monthly reminder to check for Node.js updates, clean up unused versions, and review your global packages. This simple maintenance routine will keep your development environment optimal and secure.

Start with the LTS version for stability, experiment with current releases for new features, and use project-specific .nvmrc files for team consistency. With this comprehensive setup, you're well-equipped to tackle any Node.js development challenge on Ubuntu.