Should some microservices share a database?



1814 views Designing μ-services



Microservices need to communicate with each other, and one such way of doing it is through a shared database.

For example: While building a multi-user blogging application, say we have a Blogs service that manages all the blogs-related information and we have an Analytics service that takes care of all the analytics like Likes, Shares, Views, etc.

Analytics service updates the information asynchronously directly in the blog’s database; eg: total_views that happened on the blog. This can be easily achieved by sharing the database between Blogs and Analytics, and this pattern is the Shared Database pattern.

Advantages of sharing the database

  • the simplest way of integration
  • no middleman involved
  • no latency overhead
  • quick development time

Challenges with Shared Database

There are 4 challenges to using this pattern

External parties know internal details

By sharing the database across services, an external party (Analytics) would get to know the internal details of the Blogs service; eg: deletion practice, schema, etc.

This leads to a very tight coupling between the services; which then restrains the maintainability and performance of the system. For example, whenever the Blogs service changes the schema, the Analytics Service would have to be informed about the change.

Sharing the database is sharing the logic

To compute some information we need to query a set of tables; and say, this information is required by the Blogs, Analytics, and Recommendation service.

The business logic to compute the information has to be replicated across all the 3 services. Any change in the logic needs to be made across all the services.

Risk of data corruption and deletion

There is a risk that one of the services might corrupt or delete some data given that the database is shared between the services.

Abusing the shared database

One service firing expensive queries on the database will affect the performance of other services sharing the same database.

When to share a database?

A shared database pattern is helpful when you are seeking quick development time. Although it is not the best practice, sharing the database does reduce the development effort by a massive margin.

Sharing the database is also seen where it is inconvenient to have a middleman for the communication; for example: sending a notification to a million followers of a person is simple when the Relationship database is shared with the notification fan-out service; instead of iterating the millions of followers through some middleman API.


Arpit Bhayani

Arpit's Newsletter

CS newsletter for the curious engineers

❤️ by 14000+ readers

If you like what you read subscribe you can always subscribe to my newsletter and get the post delivered straight to your inbox. I write essays on various engineering topics and share it through my weekly newsletter.




Other videos that you might like


Introduction to RPC - Remote Procedure Calls

1531 views 97 likes 2022-05-13

One of the most interesting things that revived itself after a decade is Remote Procedure Calls, fondly called as RPCs; ...

Designing Workflows in Microservices - Orchestration vs Choreography

1659 views 111 likes 2022-05-11

In a microservices architecture there will always arise a need to design workflows; for example: when on an e-commerce w...

Synchronous and Asynchronous Communication between Microservices

1646 views 106 likes 2022-05-04

How should two microservices talk to each other? Picking the right communication pattern is super-important as a good de...

Should some microservices share a database?

1814 views 97 likes 2022-04-27

Microservices need to communicate with each other. Communication between them is always about getting or updating data t...


Arpit's Newsletter read by 14000+ engineers

🔥 Thrice a week, in your inbox, an essay about system design, distributed systems, microservices, programming languages internals, or a deep dive on some super-clever algorithm, or just a few tips on building highly scalable distributed systems.



  • v10.6.4
  • © Arpit Bhayani, 2022