It comes down to balancing risks, costs and benefits - which of your problems is more likely to happen, and how bad would things be if it did?
How often does an update to the reference data not get applied to everywhere? How bad is it when this happens? Is it as bad if an update will get applied everywhere, but only eventually rather than immediately? And so on.
Compare that to: How often do databases crash? How bad is it if that happens? And so on.
How important is it that the system is simple? Is it already hard to manage? If so, is it the code or the database that's the harder bit?
There are several options I can think of; which is best will depend on your circumstances. The circumstances include what technology you already have skills in, what your technology strategy is etc.
- You could keep things as they are.
- You could change to a single large shared db, with appropriate availability safeguards. This means the sites will always be completely in sync, but back-ups and upgrades will be bigger and harder, and the sites are tied together (which might not fit so well with your organisation structure).
- If you have a single system of record for the reference data, whatever updates that could be changed to also apply those updates to the other databases. This doesn't scale so well, it's not transactionally secure (so a given site might miss an update if the update code crashes) but keeps the database side of things unchanged and might be good enough.
- You could split each database into 2: 1 part for the reference data (that's the same for each site) and 1 part for everything else (that's different for each site). You can set up replication from the system of record for the reference data out to the other instances, and then change the client code to read both parts of the database.
- If you already have some kind of shared infrastructure between the different sites e.g. a shared message queue as in micro-services, the thing that updates the system of record could also put a message onto the queue, which gets read by each website and leads to it updating its own database. (This would be eventual consistency rather than immediate, but that might be good enough.)