Microservices Architecture with Node.js

// Monolith: a function call, fast and simple, fails atomically
const inventory = checkInventory(productId);

// Microservices: a network call, can fail independently and partially
try {
  const response = await fetch(`http://inventory-service/products/${productId}`);
  const inventory = await response.json();
} catch (err) {
  // must now explicitly handle network failures, timeouts, retries...
}

Common follow-ups: At what team size or codebase complexity does the overhead of microservices typically start to be worth the added operational cost?;What's a 'modular monolith' as a middle-ground approach between a single monolith and full microservices?

// Kubernetes DNS-based service discovery: no IP addresses hardcoded anywhere
const response = await fetch('http://inventory-service.default.svc.cluster.local/products/123');
// Kubernetes automatically resolves 'inventory-service' to a currently healthy pod IP

Common follow-ups: How does DNS-based discovery handle load balancing across multiple healthy instances of the same service?;What additional capabilities does a full service mesh provide beyond basic discovery, like automatic retries and circuit breaking?

// Simplified API Gateway routing logic
app.use('/api/users', authenticate, proxy('http://user-service:3001'));
app.use('/api/orders', authenticate, proxy('http://order-service:3002'));
app.use('/api/products', proxy('http://product-service:3003')); // no auth needed for public data

Common follow-ups: How does an API Gateway avoid becoming a single point of failure or a performance bottleneck for the entire system?;What's the difference between a general-purpose API Gateway product (like Kong or AWS API Gateway) and a hand-rolled Express-based gateway?

// Anti-pattern: order-service reaching directly into inventory-service's database
const inventory = await inventoryDb.query('SELECT * FROM stock WHERE product_id = ?', [productId]);

// Correct: order-service goes through inventory-service's own API instead
const response = await fetch('http://inventory-service/api/stock/' + productId);
const inventory = await response.json();

Common follow-ups: How do you handle a legitimate need for data from another service's domain without resorting to shared database access, like via an API call or an event-driven data replication approach?;What's the CQRS-style approach of maintaining a service's own local, denormalized read-copy of another service's data?

// OAuth client credentials grant for service-to-service auth
async function getServiceToken() {
  const response = await fetch('https://auth.internal/token', {
    method: 'POST',
    body: new URLSearchParams({
      grant_type: 'client_credentials',
      client_id: process.env.SERVICE_CLIENT_ID,
      client_secret: process.env.SERVICE_CLIENT_SECRET,
    }),
  });
  return (await response.json()).access_token;
}

Common follow-ups: How does relying on a service mesh for this concern compare to implementing service-to-service auth manually within each application?;What's the risk of trusting requests based solely on network location (like 'it came from inside the VPC') without any cryptographic authentication at all?