When several services depend on the same business definitions, the hard problem may not be copying the data—it may be deciding who owns its meaning. In Denis Toropov’s account, three balance-related services had separate databases for good reasons, but each maintained shared reference data such as account types, statuses, product attributes and classifiers. Different refresh paths let those definitions drift. The team chose a dedicated reference data service to establish a clear owner, while distinguishing central ownership from requiring every consumer to make a live call.
How do you manage shared reference data across microservices?
Start by deciding which service owns the model and the rules for changing it. Then define how consumers learn about changes and choose a read strategy that fits their latency, freshness and availability needs. A dedicated reference data service is one way to do this; it is not a requirement to centralize every database or route every read through one endpoint.
As an Amazon Associate I earn from qualifying purchases.
Toropov describes three separate balance databases: one behind an account display service, one for customer-level balances, and one for current account balances. Each served different read patterns, performance requirements and data representations. All three also relied on common reference entities. An account balance is only meaningful in context: an account type, status or product attribute can affect how the number is categorized and understood.
The trouble was that the shared definitions were refreshed differently. One service used a schedule, another reacted to an event, and a third relied on a separate integration flow. Updates did not necessarily arrive together, so different views could apply different versions or local mappings. When interpretations disagreed, diagnosis could cross three services, databases, update histories and teams.
#1 Best Overall
Why did the team move the data?
The choice was not simply whether to store a copy or eliminate copies. It was whether there was an accountable owner for shared business semantics. Toropov’s explanation is that the underlying issue was “multiple owners of the same business semantics.” A shared database could consolidate storage without settling who controls its schema, contract or behavior.
The account describes reconciliation and prolonged diagnosis as recurring operational pain, not a quantified outage. It reports a clearer architecture and fewer collisions as consequences of the change, but gives no before-and-after figures for incidents, latency, cost or staff time. Treat the result as one team’s experience, not proof that extraction will improve outcomes for every system.
What are the options for shared reference data?
| Approach | Ownership and change | Read and distribution trade-offs |
|---|---|---|
| Keep local copies and improve synchronization | Each consumer retains its local representation; teams still need rules for who changes the shared meaning. | Preserves local reads and autonomy, but duplication and synchronization work remain. Consumers can still drift if delivery or interpretation differs. |
| Use a shared reference database | Storage is centralized, but schema and behavior ownership may remain unclear without an explicit contract owner. | Can avoid multiple independently maintained stores, but direct schema coupling or duplicated consumer-side rules may result. |
| Create a dedicated reference data service | A domain owner governs the model, versions, validation and publication of changes. | Offers an explicit contract and distribution point, but introduces a component with availability and operational obligations. |
These are design alternatives, not a universal ranking. Sam Newman’s Monolith to Microservices discusses reference data as something that can be duplicated, placed in a dedicated schema, distributed in a shared library or served by a dedicated service. The appropriate pattern depends on the data and the system around it.
What should a dedicated reference data service own?
It should own the reference model, rather than act as a thin CRUD wrapper. In Toropov’s account, that responsibility includes:
- Defining fields, relationships, constraints and lifecycle rules.
- Supporting explicit versions so consumers can identify which definition they use.
- Publishing changes predictably through an API, events, snapshots or a hybrid.
- Validating and auditing updates.
- Monitoring data freshness, update failures and consumer lag.
These responsibilities make ownership concrete: consumers can know where a definition comes from, what constitutes a valid change and how a release reaches them. A service that merely stores records without governing their meaning would not resolve the original ownership problem.
Who is the source of truth for a reference entity?
The source of truth should be the explicitly accountable owner of the entity’s definition and change process—not automatically the database that happens to contain a copy. The owner should specify the contract, versioning rules and publication path. Consumers may still hold local projections, but those projections should be understood as read-optimized representations of centrally governed data, not independent authorities on its meaning.
This separates two decisions that are often conflated: centralized write ownership and centralized runtime reads. Toropov puts it succinctly: “The important nuance is that we centralized ownership, not necessarily every online read.” A canonical owner can govern changes while consumers retain local read models where workload or latency makes that useful.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
How should consumers receive changes?
Choose a delivery mechanism based on how quickly consumers need updates and what they can operate reliably. An API can provide an explicit way to retrieve the current definition; events can announce changes; snapshots can provide a complete view at a chosen point. A hybrid can combine these—for example, a snapshot for initial loading and events for subsequent changes. The case account names these as options, but does not prescribe one universal mechanism.
Whichever method is chosen, make version and freshness visible. A consumer should be able to determine which version it has applied, when it last updated, and whether an update failed or lagged. Otherwise, central ownership may be clear while operational diagnosis remains difficult.
Rank #4
What if one system uses the new version while another still uses the old one?
Version skew is a normal possibility in distributed systems; publishing a change does not guarantee that every consumer applies it at the same instant. The design should make that skew observable and define how consumers behave during the transition.
- Identify the active version and the version each consumer has applied.
- Track update failures and consumer lag so stale data is distinguishable from current data.
- Define lifecycle and compatibility rules for changes, including how consumers move to a new version.
- Decide which operations can tolerate different versions temporarily and which require coordinated rollout or validation.
The source account emphasizes explicit versions, predictable publication and freshness monitoring; it does not specify a rollout protocol or compatibility scheme. Those details need to be decided for the actual domain rather than inferred from the choice to create a service.
Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchWindows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallShould every read call the reference data service?
Not necessarily. A synchronous call centralizes lookup, but it also makes the owner part of the consumer’s request-time availability and latency path. If the service degrades, dependent services may degrade with it. For high-volume or latency-sensitive reads, a local projection can reduce that runtime dependency, provided the system accepts and monitors its freshness.
Best Value
Choose among synchronous reads, local projections and event- or snapshot-fed copies by weighing read latency, acceptable staleness, availability dependency, failure isolation and operational complexity. Centralizing who may change a definition does not require centralizing every read of it.
How can a team decide whether extraction is worth it?
Use the actual failure mode and operating cost to guide the choice. A dedicated service is more compelling when shared definitions change under unclear ownership, consumers apply inconsistent rules, or investigations repeatedly require tracing separate update histories. If the data is stable and synchronization is simple, improving local-copy management may cost less than operating another critical component.
Compare the options against these questions:
- Who can change the model, and who approves or audits changes?
- How does each consumer know which version is active?
- How are changes distributed, and how are failures or lag detected?
- What are the read-latency and availability consequences of a runtime dependency?
- How much local autonomy and failure isolation do consumers need?
- How difficult are audits, reconciliation and investigations under the current design?
These are decision axes raised by the case, not a benchmark or scoring formula. The service adds an operational responsibility: it must be available enough for its role, and its distribution mechanisms need monitoring. The reported account does not quantify whether the move reduced incidents, cost or latency.
Recommended Free Tools
Sources and scope
This case is Denis Toropov’s first-person account, published on DEV Community on September 20, 2026: “When the Same Reference Data Lives in Three Services: Why We Moved It into a Dedicated Service”. Pattern context comes from Sam Newman, Monolith to Microservices: Evolutionary Patterns to Transform Your Monolith (O’Reilly Media, 2019). The experience described is specific to one team; it does not establish a universally superior architecture.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
