As a general consideration, a distributed system has significant overhead (for example, non-user calculations) that represent a “consistent” and “unified” facade.
Just consider the following factors:
different nodes (e.g. servers) are different machines. This means the likelihood of n nodes participating in the distributed action - for example, a connection in the optimal state (for example, only the correct tables in the cache or the presence of corresponding locks) is low. So, here are some of the overhead for each node to get into the appropriate state.
Naturally, they must communicate for coordination. Thus, there is network chatter between nodes, and these delays are not negligible.
higher overheads, in turn, increase the average time for servicing requests and, consequently, reduce availability (in terms of system bandwidth).
Scalability is becoming a problem, since none of the above is O (1). At best, you can expect O (log n), and it can be as bad as O (n ^ 2). This works wonders for increasing scalability (which by definition means the ability of the system to scale to more nodes).
The above are part of the motivation for noSQL systems, for example. if query servicing does not require coordination between nodes, then performance is much better. (As you can see, this is not magic — we simply sacrifice systemic correctness for performance.)