Node.js Microservices Without Express: A Zero-Dependency Guide

Why Skip the Usual Stack

What Actually Makes Something a Microservice

• Independent deployability — you can redeploy the order service without touching, restarting, or rebuilding the user service.
• Single responsibility — the user service knows about users. It does not know what an order is.
• Owning its own data — each service controls its own storage. Two services reading and writing the same table directly is a monolith with extra network hops.

The Approach: Two Services, Zero Dependencies

project/
  user-service/
    package.json
    index.js
    index.test.js
  order-service/
    package.json
    index.js
    index.test.js

{
  "name": "user-service",
  "type": "module",
  "scripts": {
    "dev": "node --watch index.js",
    "test": "node --test"
  }
}

Building Both Services Step by Step

1. 1

   Build the user service with node:http

   The user service holds user records and answers GET /users/:id. Create user-service/index.js with the package.json shown above alongside it.

   javascript — user-service/index.jsCopy

   import { createServer } from 'node:http';
   
   const users = new Map([
     ['1', { id: '1', name: 'Amir Khan', email: 'amir@example.com' }],
     ['2', { id: '2', name: 'Sara Ali', email: 'sara@example.com' }],
   ]);
   
   function json(res, status, payload) {
     res.writeHead(status, { 'Content-Type': 'application/json' });
     res.end(JSON.stringify(payload));
   }
   
   const server = createServer((req, res) => {
     const url = new URL(req.url, `http://${req.headers.host}`);
   
     if (req.method === 'GET' && url.pathname.startsWith('/users/')) {
       const id = url.pathname.split('/')[2];
       const user = users.get(id);
   
       if (!user) return json(res, 404, { error: 'user not found' });
       return json(res, 200, user);
     }
   
     json(res, 404, { error: 'not found' });
   });
   
   const PORT = process.env.PORT || 3001;
   server.listen(PORT, () => {
     console.log(`[user-service] listening on ${PORT}`);
   });

   No routing library. URL is a global in Node, so parsing the path and branching on it with a couple of if statements is genuinely fine at this scale. The small json() helper exists because writing the header and the body separately three times gets noisy fast, and that helper is the seed of what a framework would give you.

   Start it with npm run dev and you have a service.

   

2. 2

   Test it with the built-in runner

   node:test covers what most services need: a test function, assertions, async support, and a readable TAP report. Create user-service/index.test.js.

   javascript — user-service/index.test.jsCopy

   import { test } from 'node:test';
   import assert from 'node:assert';
   
   const BASE = 'http://localhost:3001';
   
   test('fetches an existing user', async () => {
     const res = await fetch(`${BASE}/users/1`);
     const body = await res.json();
   
     assert.strictEqual(res.status, 200);
     assert.strictEqual(body.name, 'Amir Khan');
   });
   
   test('returns 404 for a missing user', async () => {
     const res = await fetch(`${BASE}/users/999`);
     assert.strictEqual(res.status, 404);
   });

   Run npm test while the service is up in another terminal.

3. 3

   Build the order service and call across the boundary

   This is where inter-service communication actually happens. The order service confirms a user exists before creating an order for them, and it does that with a plain fetch call.

   javascript — order-service/index.jsCopy

   import { createServer } from 'node:http';
   
   const orders = [];
   const USER_SERVICE_URL = process.env.USER_SERVICE_URL || 'http://localhost:3001';
   
   function json(res, status, payload) {
     res.writeHead(status, { 'Content-Type': 'application/json' });
     res.end(JSON.stringify(payload));
   }
   
   // fetch rejects on a refused connection, so a downed user service must not
   // escape this function as an unhandled rejection and take the process with it.
   async function getUser(userId) {
     try {
       const res = await fetch(`${USER_SERVICE_URL}/users/${userId}`);
       if (!res.ok) return null;
       return await res.json();
     } catch {
       return null;
     }
   }
   
   const server = createServer(async (req, res) => {
     if (req.method === 'POST' && req.url === '/orders') {
       let body = '';
       for await (const chunk of req) body += chunk;
   
       let payload;
       try {
         payload = JSON.parse(body);
       } catch {
         return json(res, 400, { error: 'invalid JSON body' });
       }
   
       const user = await getUser(payload.userId);
       if (!user) {
         return json(res, 400, { error: 'cannot create order, user unavailable' });
       }
   
       const order = {
         id: String(orders.length + 1),
         userId: payload.userId,
         item: payload.item,
         userName: user.name,
       };
       orders.push(order);
   
       return json(res, 201, order);
     }
   
     json(res, 404, { error: 'not found' });
   });
   
   const PORT = process.env.PORT || 3002;
   server.listen(PORT, () => {
     console.log(`[order-service] listening on ${PORT}, user service at ${USER_SERVICE_URL}`);
   });

   getUser is a plain fetch call. No axios, no HTTP client library, no service discovery layer. The order service only needs a URL, and at two services a URL in an environment variable is the entire service discovery story.

   The two try blocks are not boilerplate, they are the whole lesson. fetch rejects when a connection is refused rather than returning a non-ok response, so a user service that is simply down throws rather than returning a 404. Without that catch, an unhandled rejection inside the request handler takes the order service down with it: one dead service becomes two.

4. 4

   Run both services and watch a failure happen

   Open two terminal tabs, run npm run dev in each folder, then send a request to the order service from a third.

   bashCopy

   curl -X POST http://localhost:3002/orders \
     -H "Content-Type: application/json" \
     -d '{"userId":"1","item":"keyboard"}'
   
   # {"id":"1","userId":"1","item":"keyboard","userName":"Amir Khan"}

   That userName field came from a different process over the network. That is the entire mechanism behind every microservice architecture, and you wrote it in about forty lines.

   

   Now stop the user service and run the same curl again. You get a clean 400 with "user unavailable" and the order service stays up. Delete the try/catch from getUser and try once more: the process logs an unhandled rejection and the request hangs until curl gives up.

   That is the first real lesson of distributed systems, and it is much better learned in a forty-line service than in production. Any call to another service can fail, and yours has to decide what that means.

The Challenges You Hit Immediately

No service discovery

No retries or circuit breaking

async function getUserWithRetry(userId, attempts = 3) {
  for (let i = 0; i < attempts; i++) {
    try {
      const res = await fetch(`${USER_SERVICE_URL}/users/${userId}`);
      if (res.ok) return await res.json();
      if (res.status === 404) return null; // do not retry a real answer
    } catch {
      // network-level failure, fall through to the backoff below
    }
    if (i < attempts - 1) {
      await new Promise((r) => setTimeout(r, 200 * 2 ** i));
    }
  }
  return null;
}

No structured logging

No process management

Why Starting Here Beats Starting With the Full Stack

• You understand every line — there is no framework magic between your code and the socket, so when something breaks the stack trace points at code you wrote.
• It costs nothing to run — two Node processes fit on a free-tier VM, which is enough to find out whether splitting the app was even the right call.
• Onboarding is two files — a new developer reads index.js twice and understands the whole system, instead of reverse-engineering a compose file with four services and a broker.
• The work is not throwaway — the service boundary you draw here survives every later upgrade.

When to Actually Add Express, Docker, or a Queue

async function getUser(userId) {
  try {
    const res = await fetch(`${USER_SERVICE_URL}/users/${userId}`);
    if (!res.ok) return null;   // service answered, just not with a user
    return await res.json();
  } catch {
    return null;                // service did not answer at all
  }
}