I think people feel that if they introduce a new data store, they won’t have to deal with the existing nearly unusable massive data store.
Of course that just exacerbates the problem.
There are downsides to coupling more loosely with data consumers, but it keeps service owners moving without wasting time vending data.
An ETL approach from the start will save you a lot of headache.
You can't have 42 different classes directly poking the User-table for example. You need one clear location that has the responsibility for the data.
If you move the User-table to a different database schema, other places CANNOT touch it because they won't have access to it =)
Will be fun when you decide that you want to have organizations to be linked to orders instead of users.
All this to say, data management and having more than one source of truth complicates your world a lot. The responsibility for writing the data has to be solved at the appropriate layer: only one entity writing it.
Why should your order manager service be tightly-coupled to your IAM service when the only responsibility it has is to store a single ID?
You might be databasing wrong if that results in two sources of truth.
Most data problems can be fixed on the frontend with a few relatively simple graphql queries. /s
At SendGrid, we had an few tables to deal with IP management. Over time, the like 5 tables were in use by 15+ services owned by different teams with competing priorities. When we finally had to scale the database, it took over three quarters of working with other teams while we supported both legacy and the new hotness.
It is hard to see early on where whole teams can sprout up and have domain ownership and to know which areas will be common/platform-like for other teams. But as soon as two services share a table, you should see a train coming at you.
Joins are good, actually, and normalisation should be the default. It's much easier to keep things consistent by default rather than trying to make them somewhat consistent afterwards. When something becomes a problem there is a bunch of tools (from denormalisation or materialised views to specialised datastores) to deal with that, but before that it's just premature optimisation.
No matter how hard you modularize and instrument your service, that won't give you regional deployments, which you absolutely need to have ti be able to drive down customer-facing latencies from many hundreds of milliseconds to a few tens of milliseconds.
How do you pull that off with a monolith when you have a global userbase?
Respectfully disagree. At this point you start refactoring your monolith into components and actually look at performance measurements via tracing.
Do not do microservices when you're growing (or ever, most of the time).
And by the love of god, don't split your data. Data is much more complex to manage than code.