Node.js初心者が3ヶ月でサーバーサイド開発をマスターした話

2025年11月27日

新垣亮

あのときの私は、サーバーサイドが怖かった

2019年の夏、私はフロントエンドエンジニアとして働いていた。HTML、CSS、JavaScriptは得意。Reactでのコンポーネント開発も問題なくこなせてた。でも、サーバーサイドには手を出したことがなかった。

「データベースとか、API設計とか、難しそう…」

そんな漠然とした不安があった。フロントだけやってれば食っていけるし、わざわざ苦手なことに挑戦する必要もないかなって。

転機が訪れたのは、副業案件の打ち合わせだった。クライアントから「簡単なAPIサーバーも作ってもらえますか？」って聞かれた。報酬は倍。でも私は断った。できなかったから。

その夜、めちゃくちゃ悔しかった。「あれができれば月10万円多く稼げたのに」って。で、その日からNode.jsの学習を始めた。

3ヶ月後、私は同じクライアントに「今ならできます」って連絡した。無事に案件を獲得。報酬は月25万円。フロントだけの案件の倍以上だった。

あれから5年。今はフルスタックエンジニアとして、サーバーサイドもフロントも両方こなせる。副業収入も月50万円を超えてる。Node.jsを学んだことで、エンジニアとしての市場価値が2倍になった。

この記事では、「Node.jsって何？」「サーバーサイド開発ってどうやって学ぶの？」って思ってる初心者に向けて、私が実際に歩んだ学習ロードマップと、現場で使える実践的な知識を全部話していく。

プログラミング学習中の人、フロントエンドエンジニアからステップアップしたい人、副業で稼ぎたい人。Node.jsは、今一番習得すべきスキルの一つ。需要が高くて、学習コストが低くて、すぐに実務で使える。

実際、私がメンターしてる受講生の中にも、Node.js学習を始めて2ヶ月でサーバーサイド案件を取った人がいる。特別な才能なんて要らない。正しい手順で、正しく学べば、誰でもできるようになる。

Node.jsって何？なぜ今学ぶべきなのか

JavaScriptでサーバーが動かせる革命

Node.jsを一言で説明すると、「JavaScriptをサーバーサイドで動かせる環境」。

従来、サーバーサイド開発にはPHP、Ruby、Python、Javaなどが使われてた。でも、これらの言語を学ぶには時間がかかる。フロントエンドエンジニアが新しくサーバーサイド言語を習得するのは、けっこうハードルが高かった。

Node.jsの登場で、何が変わったか？

すでにJavaScriptを知ってれば、すぐにサーバーサイド開発ができる。新しい言語を覚える必要がない。これ、めちゃくちゃ大きいメリット。

私がNode.jsを選んだ理由もこれ。「JavaScriptなら仕事で毎日使ってる。サーバーサイドもJavaScriptなら、学習コスト低そう」って思った。実際、その通りだった。

最初の「Hello World」を表示するサーバーを作るのに、たった10行。

// server.js
const http = require('http');

const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('Hello World');
});

server.listen(3000, () => {
  console.log('サーバーが起動しました: http://localhost:3000');
});

これだけ。たったこれだけで、Webサーバーが動く。初めて実行したとき、「え、これだけ？」って驚いた。

圧倒的に高い求人需要

Node.jsエンジニアの需要は、ここ数年で爆発的に増えてる。

Indeedで「Node.js」って検索すると、2万件以上の求人が出てくる。しかも、年収600万円～1,000万円超の案件がゴロゴロしてる。

フリーランス案件も豊富。レバテックフリーランスで見ると、Node.js案件の平均単価は月70～90万円。しかもリモートワーク可能な案件が7割以上。

私が最初にNode.js案件を取ったときの単価は月50万円（週3日稼働）。時給換算で約1万円。フロントだけの案件より、明らかに単価が高かった。

なぜこんなに需要が高いのか？理由は3つ。

モダンなWeb開発に必須
React、Vue.js、Next.jsなど、モダンなフロントエンド開発環境は、ほぼすべてNode.jsベース。ビルドツールもNode.js。つまり、フロントエンド開発でもNode.jsの知識は必須。
リアルタイム処理に強い
チャットアプリ、ライブ配信、リアルタイム通知など、リアルタイム性が求められるサービスでNode.jsが選ばれる。WebSocketを使った実装が簡単。
マイクロサービスとの相性がいい
小さな機能単位でサービスを分割するマイクロサービスアーキテクチャ。Node.jsは起動が速くて軽量だから、マイクロサービスに最適。大手企業も次々と採用してる。

フロントエンドとの親和性が高すぎる

これが一番大きい。フロントエンドエンジニアがサーバーサイドを学ぶなら、Node.js一択。

理由：

言語が同じ（JavaScript/TypeScript）
npmパッケージが共通
JSONでのデータ受け渡しが自然
フロントとバックエンドで同じツールが使える

実際、私がNode.jsを学び始めたとき、「あ、これフロントで使ってるやつと同じだ」って瞬間が何度もあった。

非同期処理？Promiseとasync/awaitで慣れてる。モジュール化？ES6のimport/exportと似てる。パッケージ管理？npmは毎日使ってる。

既存の知識がそのまま活きる。これが、Node.js学習の最大の強み。

リアルタイムアプリが簡単に作れる

チャットアプリ、オンラインゲーム、リアルタイム共同編集ツール。こういうアプリを作るなら、Node.jsが圧倒的に楽。

理由は「イベント駆動型」のアーキテクチャ。Node.jsは、イベントが発生したときに処理を実行する仕組みになってる。だから、リアルタイム通信との相性が抜群にいい。

私が初めてリアルタイムチャットを作ったとき、Socket.ioっていうライブラリを使った。コードは驚くほど少なかった。

// サーバー側（server.js）
const io = require('socket.io')(3000);

io.on('connection', (socket) => {
  console.log('ユーザーが接続しました');

  // メッセージを受信したら、全員に送信
  socket.on('message', (msg) => {
    io.emit('message', msg);
  });
});

たったこれだけで、リアルタイムチャットのサーバーが完成。クライアント側も同じくらいシンプル。

従来のサーバーサイド言語だと、こういう実装はかなり面倒だった。でもNode.jsなら、初心者でも数時間で作れる。

Node.js学習の正しいロードマップ

ステップ1：環境構築と基礎理解（1週間）

まずはNode.jsをインストールして、動かしてみる。ここでつまずく人が多いけど、実は超簡単。

やること：

Node.jsのインストール（公式サイトからLTS版）
npmの基本コマンドを覚える
最初のサーバーを起動してみる

インストール方法：

nodejs.orgにアクセス
LTS版（安定版）をダウンロード
インストーラーの指示に従う

インストールできたか確認：

// ターミナルで実行
node -v  // Node.jsのバージョンが表示されればOK
npm -v   // npmのバージョンが表示されればOK

私が最初にやったのは、公式ドキュメントの「Getting Started」を読むこと。英語だけど、コードを見れば何となく理解できる。

最初のプロジェクト作成：

// 1. プロジェクトフォルダを作成
mkdir my-first-server
cd my-first-server

// 2. package.jsonを作成
npm init -y

// 3. server.jsを作成して、先ほどのHello Worldコードを書く

// 4. サーバーを起動
node server.js

ブラウザでhttp://localhost:3000にアクセス。「Hello World」が表示されたら成功。

この瞬間、「おお、サーバー動いた！」ってテンション上がった。自分が書いたコードでサーバーが動くって、めちゃくちゃ感動する。

ステップ2：Expressフレームワークの習得（1～2週間）

Node.jsの標準機能だけでサーバーを作るのは大変。だから、みんなExpressっていうフレームワークを使う。

Expressは、Node.jsで最も人気のあるWebフレームワーク。ルーティング、ミドルウェア、リクエスト・レスポンス処理が超簡単にできる。

学ぶこと：

ルーティング（URLに応じた処理の振り分け）
ミドルウェアの使い方
リクエストとレスポンスの扱い
静的ファイルの配信

Expressのインストール：

npm install express

基本的なExpressサーバー：

// app.js
const express = require('express');
const app = express();

// ルーティング
app.get('/', (req, res) => {
  res.send('ホームページです');
});

app.get('/about', (req, res) => {
  res.send('このサイトについて');
});

// サーバー起動
app.listen(3000, () => {
  console.log('サーバーが起動しました: http://localhost:3000');
});

これだけで、複数のページを持つWebサーバーが完成。標準のhttpモジュールより圧倒的に書きやすい。

私が最初にExpressを使ったとき、「なんでこんなに簡単なの？」って思った。ルーティングがこんなに直感的に書けるなんて。

ミドルウェアの理解：

Expressの強みは、ミドルウェアっていう仕組み。リクエストを受けてから、レスポンスを返すまでの間に、いろんな処理を挟める。

// ログを出力するミドルウェア
app.use((req, res, next) => {
  console.log(`${req.method} ${req.url}`);
  next(); // 次の処理へ
});

// JSONを受け取れるようにする
app.use(express.json());

// 静的ファイルを配信
app.use(express.static('public'));

このミドルウェアの概念、最初はちょっと理解しにくかった。でも、一度わかると超便利。認証、ログ、エラーハンドリング、全部ミドルウェアで処理できる。

実践課題：

TODOリストのCRUD API（作成・読み取り・更新・削除）を作る
ユーザー登録・ログイン画面を作る
簡単なブログシステムを作る

私は最初、簡単なメモアプリのAPIを作った。データはとりあえず配列に保存（データベースはまだ使わない）。これで、Expressの基礎は完璧に理解できた。

深夜、コワーキングスペースでExpressのコードをデバッグする40代男性の線画イラスト

ステップ3：データベース連携（2～3週間）

サーバーサイド開発で避けて通れないのが、データベース。ここが一番の山場。でも、Node.jsとデータベースの連携は、思ったより簡単だった。

おすすめデータベース：

MongoDB：初心者におすすめ。JSONライクなデータ構造で、JavaScriptとの相性抜群
PostgreSQL：リレーショナルDB。本格的なアプリに向いてる
MySQL：最も普及してるRDB。案件でよく使われる

私は最初、MongoDBから始めた。理由は、JavaScriptのオブジェクトをそのまま保存できるから。SQLを覚える必要がない。

MongoDBの基本：

// MongoDBライブラリをインストール
npm install mongodb

// データベース接続
const { MongoClient } = require('mongodb');
const url = 'mongodb://localhost:27017';
const client = new MongoClient(url);

async function main() {
  await client.connect();
  console.log('データベースに接続しました');

  const db = client.db('myapp');
  const users = db.collection('users');

  // ユーザーを追加
  await users.insertOne({
    name: '田中太郎',
    email: 'tanaka@example.com',
    age: 30
  });

  // ユーザーを取得
  const allUsers = await users.find({}).toArray();
  console.log(allUsers);

  await client.close();
}

main();

これだけで、データベースにデータを保存・取得できる。SQLを書く必要がないから、初心者でもハードルが低い。

Mongooseでもっと楽に：

MongoDBを直接使うより、Mongooseっていうライブラリを使う方が一般的。スキーマ定義ができて、バリデーションも自動でやってくれる。

const mongoose = require('mongoose');

// スキーマ定義
const userSchema = new mongoose.Schema({
  name: { type: String, required: true },
  email: { type: String, required: true, unique: true },
  age: { type: Number, min: 0 }
});

const User = mongoose.model('User', userSchema);

// データベース接続
mongoose.connect('mongodb://localhost:27017/myapp');

// ユーザーを作成
const newUser = new User({
  name: '山田花子',
  email: 'yamada@example.com',
  age: 25
});

await newUser.save();
console.log('ユーザーを保存しました');

Mongooseを使うと、データの整合性が保てる。実務では、ほぼ全員がMongooseを使ってる。

PostgreSQLも選択肢に：

もっと本格的なアプリを作るなら、PostgreSQL。リレーショナルデータベースだから、テーブル同士の関係性を定義できる。

// PostgreSQLライブラリをインストール
npm install pg

const { Pool } = require('pg');
const pool = new Pool({
  user: 'postgres',
  host: 'localhost',
  database: 'myapp',
  password: 'password',
  port: 5432,
});

// ユーザーを取得
const result = await pool.query('SELECT * FROM users');
console.log(result.rows);

// ユーザーを追加
await pool.query(
  'INSERT INTO users(name, email, age) VALUES($1, $2, $3)',
  ['佐藤次郎', 'sato@example.com', 28]
);

SQLを書く必要があるから、MongoDBよりちょっと難しい。でも、複雑なデータ構造を扱うなら、PostgreSQLの方が向いてる。

私の場合、最初はMongoDBで学んで、3ヶ月後にPostgreSQLも覚えた。両方できると、案件の選択肢が広がる。

ステップ4：認証とセキュリティ（2～3週間）

ユーザー登録・ログイン機能は、ほとんどのアプリで必要。でも、セキュリティを考えると、けっこう難しい。

学ぶこと：

パスワードのハッシュ化（bcrypt）
JWT（JSON Web Token）による認証
セッション管理
CORS（クロスオリジンリクエスト）対策
環境変数の管理

パスワードのハッシュ化：

パスワードを平文で保存するのは絶対NG。必ずハッシュ化する。

const bcrypt = require('bcrypt');

// パスワードをハッシュ化
const password = 'mypassword123';
const saltRounds = 10;
const hashedPassword = await bcrypt.hash(password, saltRounds);

// データベースに保存するのはhashedPassword
await User.create({
  email: 'user@example.com',
  password: hashedPassword
});

// ログイン時の検証
const isMatch = await bcrypt.compare('入力されたパスワード', hashedPassword);
if (isMatch) {
  console.log('認証成功');
}

JWTによる認証：

JWT（JSON Web Token）は、トークンベースの認証方式。ログイン成功したらトークンを発行して、以降のリクエストにそのトークンを含めることで認証する。

const jwt = require('jsonwebtoken');

// ログイン成功時、トークンを発行
const token = jwt.sign(
  { userId: user._id },
  'secret-key',  // 本番環境では環境変数で管理
  { expiresIn: '1h' }
);

res.json({ token });

// 認証が必要なエンドポイントでトークンを検証
const authMiddleware = (req, res, next) => {
  const token = req.headers.authorization?.split(' ')[1];

  if (!token) {
    return res.status(401).json({ error: '認証が必要です' });
  }

  try {
    const decoded = jwt.verify(token, 'secret-key');
    req.userId = decoded.userId;
    next();
  } catch (error) {
    res.status(401).json({ error: 'トークンが無効です' });
  }
};

// 使用例
app.get('/api/profile', authMiddleware, async (req, res) => {
  const user = await User.findById(req.userId);
  res.json(user);
});

このJWTの仕組み、最初は理解するのに苦労した。でも、一度わかると超便利。フロントエンドとの連携も簡単だし、スケーラブル（拡張しやすい）。

環境変数の管理：

APIキーやデータベースのパスワードを、コードに直接書くのはNG。環境変数で管理する。

// .envファイル
DATABASE_URL=mongodb://localhost:27017/myapp
JWT_SECRET=your-super-secret-key
PORT=3000

// アプリで読み込む（dotenvライブラリ使用）
require('dotenv').config();

const dbUrl = process.env.DATABASE_URL;
const jwtSecret = process.env.JWT_SECRET;

これ、実務では必須。GitHubにAPIキーをアップしちゃって、悪用される事件が頻繁に起きてる。絶対に環境変数で管理すること。

ステップ5：REST APIの設計と実装（2～3週間）

実務でNode.jsを使う場合、ほとんどがREST API開発。フロントエンドとバックエンドを分離して、APIで連携する設計が主流。

REST APIの基本ルール：

GETは取得、POSTは作成、PUTは更新、DELETEは削除
URLはリソース名（名詞）を使う
ステータスコードを適切に返す
JSONでデータを返す

実装例（TODOアプリのAPI）：

// GET /api/todos - 全てのTODOを取得
app.get('/api/todos', async (req, res) => {
  try {
    const todos = await Todo.find();
    res.json(todos);
  } catch (error) {
    res.status(500).json({ error: 'サーバーエラー' });
  }
});

// POST /api/todos - 新しいTODOを作成
app.post('/api/todos', async (req, res) => {
  try {
    const { title, description } = req.body;
    const todo = await Todo.create({ title, description });
    res.status(201).json(todo);
  } catch (error) {
    res.status(400).json({ error: '入力が不正です' });
  }
});

// PUT /api/todos/:id - TODOを更新
app.put('/api/todos/:id', async (req, res) => {
  try {
    const { id } = req.params;
    const { title, description, completed } = req.body;
    const todo = await Todo.findByIdAndUpdate(
      id,
      { title, description, completed },
      { new: true }
    );
    res.json(todo);
  } catch (error) {
    res.status(400).json({ error: '更新に失敗しました' });
  }
});

// DELETE /api/todos/:id - TODOを削除
app.delete('/api/todos/:id', async (req, res) => {
  try {
    await Todo.findByIdAndDelete(req.params.id);
    res.status(204).send();
  } catch (error) {
    res.status(400).json({ error: '削除に失敗しました' });
  }
});

このCRUD操作（Create, Read, Update, Delete）は、あらゆるアプリの基本。これができれば、ほとんどのAPIは作れる。

バリデーションとエラーハンドリング：

実務では、ユーザーからの入力を必ずバリデーション（検証）する。

const { body, validationResult } = require('express-validator');

app.post('/api/todos',
  // バリデーションルール
  body('title').notEmpty().withMessage('タイトルは必須です'),
  body('description').isLength({ max: 500 }).withMessage('説明は500文字以内です'),

  async (req, res) => {
    // バリデーション結果をチェック
    const errors = validationResult(req);
    if (!errors.isEmpty()) {
      return res.status(400).json({ errors: errors.array() });
    }

    // ここで実際の処理
    const todo = await Todo.create(req.body);
    res.status(201).json(todo);
  }
);

最初、バリデーションをサボってたら、変なデータが大量に入ってデータベースが壊れた。それ以来、必ずバリデーションを入れてる。

ステップ6：実践プロジェクト（3～4週間）

学んだことを全部使って、実際のアプリを作る。これが一番大事。

おすすめプロジェクト：

ブログシステム

ユーザー登録・ログイン
記事のCRUD
コメント機能
いいね機能

タスク管理アプリ

プロジェクト管理
タスクの作成・編集・削除
期限管理
進捗状況の可視化

チャットアプリ

Socket.ioでリアルタイム通信
ルーム機能
メッセージ履歴の保存

私が最初に作ったのは、簡単なブログシステム。ユーザー登録、ログイン、記事投稿、コメント、全部実装した。3週間くらいかかったけど、これを作り切ったことで、サーバーサイド開発の全体像が見えた。

ポートフォリオとして公開：

GitHubにコードを公開
Herokuや Railway で実際にデプロイ
READMEにスクリーンショットと使用技術を書く

これが案件獲得の武器になる。クライアントに「実際に動いてるアプリがあります」って見せられるのは、めちゃくちゃ強い。

よくあるトラブルとその解決法

トラブル1：非同期処理で混乱する

Node.jsは非同期処理が基本。これ、最初は絶対に混乱する。

よくあるミス：

// これだとデータが取れない
let data;
fetchData((result) => {
  data = result;
});
console.log(data); // undefined

正しい書き方：

// Promiseを使う
const data = await fetchData();
console.log(data); // 正しく取得できる

// または
fetchData().then((data) => {
  console.log(data);
});

私も最初、コールバック地獄に陥った。ネストが10段階くらいになって、もう何が何だかわからなくなった。async/awaitを使い始めてから、コードがめちゃくちゃ読みやすくなった。

トラブル2：CORSエラーでフロントから接続できない

フロントエンドとバックエンドを別のポートで動かすと、CORSエラーが出る。

エラーメッセージ：

Access to fetch at 'http://localhost:3000/api/users' from origin 
'http://localhost:5173' has been blocked by CORS policy

解決方法：

const cors = require('cors');

// すべてのオリジンを許可（開発環境のみ）
app.use(cors());

// または、特定のオリジンのみ許可（本番環境推奨）
app.use(cors({
  origin: 'https://your-frontend.com'
}));

これ、初心者が必ずハマるポイント。私も最初、「なんでフロントから接続できないの？」って3時間くらい悩んだ。corsライブラリ入れたら一発で解決した。

自宅で深夜、CORSエラーと格闘してようやく解決した瞬間の喜ぶ表情の線画イラスト

トラブル3：エラーハンドリングを忘れてサーバーが落ちる

Node.jsは、エラーをキャッチしないとサーバーが落ちる。

悪い例：

app.get('/api/users', async (req, res) => {
  const users = await User.find(); // エラーが起きたらサーバーが落ちる
  res.json(users);
});

良い例：

app.get('/api/users', async (req, res) => {
  try {
    const users = await User.find();
    res.json(users);
  } catch (error) {
    console.error(error);
    res.status(500).json({ error: 'サーバーエラー' });
  }
});

// グローバルなエラーハンドラー
app.use((error, req, res, next) => {
  console.error(error);
  res.status(500).json({ error: 'サーバーエラーが発生しました' });
});

これ、実務では絶対必須。エラーハンドリングしてないと、ユーザーがちょっと変な操作しただけでサーバーが落ちる。

トラブル4：環境変数が読み込まれない

.envファイルを作ったのに、環境変数が読み込まれない。

原因：

dotenvの読み込みを忘れてる
.envファイルの場所が間違ってる

解決方法：

// server.jsの一番最初に書く
require('dotenv').config();

console.log(process.env.DATABASE_URL); // デバッグ用

.envファイルは、プロジェクトのルート（package.jsonと同じ場所）に置く。これ忘れると、環境変数が全部undefinedになる。

トラブル5：データベース接続が切れる

長時間稼働してると、データベースの接続が切れることがある。

解決方法：

const mongoose = require('mongoose');

mongoose.connect(process.env.DATABASE_URL, {
  useNewUrlParser: true,
  useUnifiedTopology: true,
  serverSelectionTimeoutMS: 5000,
  socketTimeoutMS: 45000,
});

mongoose.connection.on('connected', () => {
  console.log('データベースに接続しました');
});

mongoose.connection.on('error', (err) => {
  console.error('データベース接続エラー:', err);
});

mongoose.connection.on('disconnected', () => {
  console.log('データベース接続が切断されました');
});

これで、接続が切れても自動的に再接続してくれる。