Node.js Tutorial for Beginners — Where to Begin in 2026

// This is the pattern you'll use constantly
// in Node.js

async function getUser(id) {
  try {
    const response = await fetch(`/api/users/${id}`);

    if (!response.ok) {
      throw new Error(`HTTP ${response.status}`);
    }

    const user = await response.json();
    return user;
  } catch (error) {
    console.error("Failed to fetch user:", error);
    throw error;
  }
}

// If async/await feels confusing,
// stop and practice it before learning Node.

Async patterns you need to know:

1. Promise basics
   → .then().catch()
   → Promise.all()

2. async/await
   → cleaner than .then chains
   → uses try/catch for errors

3. Common mistakes to avoid
   → forgetting to await
   → not handling errors
   → blocking the event loop

Practice these before Node:
→ freeCodeCamp JavaScript course
→ MDN "Asynchronous JavaScript"
→ 20 small async exercises

Time: 1-2 weeks if starting from scratch.

Week 1: JS basics
□ Variables, let/const
□ Functions, arrow functions
□ Arrays (map, filter, reduce)
□ Objects and destructuring

Week 2: Async fundamentals
□ Promises
□ async/await
□ try/catch + error handling
□ fetch API

Week 3: Node intro
□ Install Node + npm
□ Run your first .js file
□ Understand modules
□ Read the Node docs

Resources:
→ freeCodeCamp JavaScript
→ MDN Web Docs
→ Node.js official "Getting Started"

Small projects to cement the basics:

1. Command-line calculator
   → reads two numbers from argv
   → prints the result
   → forces you to work with process.argv

2. Todo list in the terminal
   → array of items
   → add / remove / list commands
   → forces you to work with arrays + async

3. Weather CLI
   → fetch from a free weather API
   → print current temperature
   → forces you to work with async + APIs

Each project should take 1-3 hours.
Don't skip them.

Week 4: Node core
□ fs (read/write files)
□ path (file paths)
□ http (create a basic server)
□ npm (install packages)
□ package.json

Week 5: Express basics
□ Install Express
□ Routes (GET, POST, PUT, DELETE)
□ Middleware
□ Request / response
□ Error handling

Week 6: Project
□ Build a small REST API
□ Use Express + in-memory data
□ Test it with Postman or curl
□ Add error handling

Core Node concepts to understand:

1. Event loop
   → How Node handles async without threads
   → Single-threaded, non-blocking

2. Modules
   → require() vs import
   → CommonJS vs ES modules
   → node_modules folder

3. The fs module
   → readFile / writeFile
   → always async

4. The http module
   → createServer
   → request / response objects

5. package.json
   → dependencies
   → scripts
   → version

You don't need to memorize these.
But you should know they exist.

// server.js — your first Express server
const express = require("express");
const app = express();

app.use(express.json());

app.get("/", (req, res) => {
  res.json({ message: "Hello from Node!" });
});

app.get("/users/:id", (req, res) => {
  const { id } = req.params;
  res.json({ id, name: "Alice" });
});

app.listen(3000, () => {
  console.log("Server running on http://localhost:3000");
});

// Adding middleware and error handling
const express = require("express");
const app = express();

// Body parser
app.use(express.json());

// Simple logger middleware
app.use((req, res, next) => {
  console.log(`${req.method} ${req.url}`);
  next();
});

// Route
app.post("/users", (req, res, next) => {
  try {
    const { name } = req.body;
    if (!name) {
      return res.status(400).json({
        error: "name is required"
      });
    }
    res.status(201).json({ id: 1, name });
  } catch (err) {
    next(err);  // pass to error handler
  }
});

// Error handler (must be last)
app.use((err, req, res, next) => {
  console.error(err);
  res.status(500).json({ error: "Server error" });
});

app.listen(3000);

Week 7: Database basics
□ Pick one: MongoDB or PostgreSQL
□ Learn basic CRUD
□ Connect Node to the database
□ Environment variables (.env)

Week 8: Build a real API
□ User registration + login
□ JWT authentication
□ Protected routes
□ Input validation

Week 9: Polish
□ Error handling everywhere
□ Logging
□ README with setup instructions
□ Postman collection

Week 10: Deploy
□ Push to GitHub
□ Deploy to Render, Railway, or Fly.io
□ Set environment variables
□ Test the live URL
□ Add live link to README

Result: one real, live project.
That's your portfolio.

Free / cheap deployment options for beginners:

1. Render
   → free tier available
   → supports Node + databases
   → easy GitHub integration

2. Railway
   → free trial credit
   → very fast setup
   → good for small projects

3. Fly.io
   → free tier for small apps
   → more control, steeper curve

4. Vercel (serverless)
   → best for small APIs
   → no persistent server (different
     from typical Node)

5. Cyclic (deprecated but alternatives exist)

Avoid: paid-only platforms for your
first project. Deploy free, prove it
works, then upgrade if you need to.