When you create an architecture diagram, you usually try to show the services, databases, queues, and the connections between these different components. With the help of these diagrams, developers can understand how a request goes through the system and how the data flows. We also get to know which components depend on other components.
However, these diagrams cannot show all the things that a component might depend on. For example, let’s say you have two services with separate code and API endpoints. At first glance, you might think that these services are independent. But imagine that whenever you change one service, you need to make a change to the other service as well. Or maybe both of these services talk to the same database whose capacity can be consumed by either service. Perhaps both of them rely on a common logging system.
You can think of these dependencies as hidden forms of coupling. If not handled properly, hidden coupling can have a big impact on the health of your system. Also, it can affect how you change things in your system, or how deployments are done. Or how recovery happens. In this article, we’ll look at the various forms of hidden coupling and how you can deal with them. Here’s what we will cover:
The various dimensions of coupling
Temporal coupling
Semantic coupling
Deployment coupling
Shared schemas and libraries
Observability coupling
Shared incidents
