{"id":1078,"date":"2026-10-08T11:52:17","date_gmt":"2026-10-08T03:52:17","guid":{"rendered":"http:\/\/www.holicfactory.com\/blog\/?p=1078"},"modified":"2026-10-08T11:52:17","modified_gmt":"2026-10-08T03:52:17","slug":"how-to-communicate-between-microservices-in-an-express-based-system-4332-1beae6","status":"publish","type":"post","link":"http:\/\/www.holicfactory.com\/blog\/2026\/10\/08\/how-to-communicate-between-microservices-in-an-express-based-system-4332-1beae6\/","title":{"rendered":"How to communicate between microservices in an Express – based system?"},"content":{"rendered":"

Alright, let\u2019s cut to the chase: if you\u2019re building microservices with Express, you already know that one of the biggest headaches isn\u2019t writing the routes\u2014it\u2019s making all those little service pieces talk to each other without everything breaking. As someone who\u2019s been building Express-based tools for teams like yours for years (yeah, I run the vendor side of this stuff), I\u2019ve seen so many teams mess up communication between services and end up with slow, janky, or even down systems. Let\u2019s break this down like we\u2019re chatting over coffee, no boring enterprise jargon. Express<\/a><\/p>\n

<\/p>\n

First, let\u2019s get one thing straight: there\u2019s no \u201cone size fits all\u201d here. What works for a tiny 2-service app will crash and burn for a 10-service e-commerce stack. I\u2019ve seen teams use raw HTTP calls like it\u2019s 2010 and wonder why their checkout page takes 3 extra seconds because it\u2019s waiting on the inventory service. I\u2019ve also seen teams overcomplicate it with gRPC for a 2-service internal tool, and now they\u2019re drowning in proto files and error handling. Let\u2019s start with the basics that almost every Express dev should know first, then move to the more advanced stuff that solves real pain points.<\/p>\n

1. The Go-To: Synchronous HTTP (But Don\u2019t Suck At It)<\/h3>\n

Let\u2019s be real\u2014most microservice comms start with plain old HTTP. Express makes this easy with built-in fetch<\/code> (or if you\u2019re on an older Node version, axios<\/code> or got<\/code>). Wait, but here\u2019s where teams mess up: they just call another service\u2019s endpoint, no retries, no timeouts, no error handling. If the payment service is slow during a flash sale, your order service is going to hang, and users will see spinning wheels until it times out (which is like 30 seconds\u2014yikes).<\/p>\n

Here\u2019s how we do it right at our vendor shop: we wrap all external service calls in a tiny retry wrapper, with exponential backoff. For example, if you call the user service to get a user\u2019s address, you don\u2019t just do fetch('https:\/\/user-service.com\/users\/123')<\/code>. You do something like:<\/p>\n

const callUserService = async (userId) => {\n  let retries = 0;\n  const maxRetries = 3;\n  while (retries < maxRetries) {\n    try {\n      const res = await fetch(`https:\/\/user-service.com\/users\/${userId}`, { timeout: 5000 }); \/\/ 5s timeout, not 30!\n      if (!res.ok) throw new Error(`HTTP error: ${res.status}`);\n      return res.json();\n    } catch (err) {\n      retries++;\n      if (retries === maxRetries) throw new Error(`Failed to reach user service after ${maxRetries} retries`);\n      await new Promise(res => setTimeout(res, 100 * retries)); \/\/ backoff: 100ms, then 200ms, then 400ms\n    }\n  }\n};\n<\/code><\/pre>\n
This is non-negotiable. No timeouts = cascading failures. I\u2019ve had a client come to us because their support team was getting 100+ tickets from users who couldn\u2019t check out, and it all traced back to them forgetting to set a timeout on their HTTP calls. We fixed that in an hour, and their checkout speed jumped 40%.<\/p>\n
Another quick win here: use service discovery, not hardcoded URLs. If you\u2019re running in Kubernetes or even just a Docker Compose stack, tools like Consul or even just environment variables let you point USER_SERVICE_URL<\/code> to whatever instance is running, instead of changing code every time you deploy a new service. At our shop, we tell all our Express clients to set every service\u2019s base URL as an env var\u2014no more http:\/\/localhost:3001<\/code> scattered through code that\u2019s running in production on a different port.<\/p>\n
2. When Sync Is A Bad Idea: Asynchronous Messaging (Event-Driven Stuff)<\/h3>\n
Okay, so sync works for things that need a direct response (like getting a user\u2019s address to show on an order), but what about things that don\u2019t? Like, when a user places an order, you need to update inventory, send an email to the customer, and log the order in your analytics service. If you do that synchronously, the order API will take forever to respond, and if one of those services is down, the order will fail entirely\u2014even if the payment went through. That\u2019s a huge UX fail.<\/p>\n
Enter event-driven messaging. This is where services publish events when something happens, and other services subscribe to those events to do their work. For Express, the easiest way to start is with something like RabbitMQ or Kafka\u2014wait, but RabbitMQ is way simpler for small to medium teams, and we recommend it to 90% of our clients before they outgrow it. Here\u2019s how this works in practice: when your order service gets a POST \/orders<\/code> request, it saves the order to its database first, then publishes an order.created<\/code> event with the order ID and user ID. Then:<\/p>\n