Mercur

Single Source of Truth on a Marketplace: Who Owns Which Data

Technology and integrations~17 min

Discuss with AI

Single Source of Truth on a Marketplace: Who Owns Which Data

A single source of truth is an arrangement in which every piece of data is created and corrected in one place, and every other system only reads a copy of it. The one place that holds the authoritative copy of a given piece of data is called its system of record.

Your marketplace is a dozen or more systems. Each of them holds a copy of the same product, the same price, and the same order.

If you don't decide whose copy wins, the copy that syncs last wins. You pay for that in support hours, and in fixes your team makes twice.

This article breaks down:

  • How do you recognize a single source of truth on a marketplace?
  • Which 3 rights can a system have over marketplace data?
  • Who owns each of the 7 objects a marketplace shares between systems?
  • What happens when two systems write different data into the same field in the same minute?

Key insights

  • You recognize a single source of truth on a marketplace by asking your support team which one screen they open to fix a mistake. The fix also has to survive the next sync, or it turns into repeated work.
  • A system can have 3 rights over marketplace data: it creates an object, enriches it, or wins a conflict about it. Only the third right settles a dispute, and you assign it to classes of sources, such as all 300 sellers together.
  • The 7 objects a marketplace shares are the product page, the price and offer, the stock level, the order, the buyer, the balance, and the document. Three of them have no screen for a manual fix at all: you correct the stock level, the balance, and the document with a new entry.
  • When two systems write different data into the same field in the same minute, one of four rules decides: the newer write, the higher-ranked source, a locked field, or a person. Most integrations default to the newer write. Your team's correction then loses to the seller's file every time the file arrives.

How do you recognize a single source of truth on a marketplace?

Two-question test for a source of truth: which single screen fixes the value, and what happens to the fix after the next sync — with three possible answers: one screen and the fix survives, two screens, or the fix is gone by morning.

Take one wrong entry. The product page promises delivery in 2 days, and the seller dispatches the goods in 5.

Ask someone on your support team which screen they open to fix that. Then ask what happens to the fix after the next sync. A single source of truth needs the right answer to both questions.

1. Which screen does your team open to fix a mistake?

Two people may name two different screens. One of them may say that you have to fix it in two places, or it comes back. You don't have a single source of truth in either case, whatever the architecture diagram shows.

The term itself means exactly this. You design the data so that every element is edited in one place, and every other system only reads it.

Copies are allowed, and in practice you can't avoid them. You have a defect when people can edit the same element in two places.

2. Does the fix survive the next sync?

If the nightly sync overwrites a correction, your team did the work, and the data is still wrong. The chapter on product data ownership covers write precedence on the product page field by field. The same test works on a price, an order, a document, and a balance.

Some platforms have a worse version of this problem, and it's hard to spot. The seller edits their own copy of the page, while the buyer sees the platform's copy.

The seller corrects the color, saves, and gets a confirmation. The page doesn't change. The seller thinks the fix worked, and the buyer still sees the old color.

Some implementations have the reverse problem. A manual correction by the operator on a shared page takes away the seller's right to edit that page for good. One click changes the owner of the object, and no one notices for a year.

Don't pick the screen for fixes because it's the easiest one to use. That screen is almost never the right one. Pick the right screen first, and then make it easy to use.

Which 3 rights can a system have over marketplace data?

Three rights over a data object — creates, enriches, wins a conflict — with the order example, the mistake of gluing the first to the third, and the rule to rank source classes rather than individual systems.

The word "owner" covers three different rights. Separate the three rights, and most arguments about data ownership stop.

1. Right to create

The system that creates an object gives it its identifier. It's also where the event happened.

Your online store creates the order, because the buyer pressed the button there. The seller creates the product page. Sellers supply almost the entire catalog in large implementations.

2. Right to enrich

An enriching system adds fields the creator doesn't know. On an order, the seller adds acceptance and dispatch. The carrier adds delivery, and the payment provider adds the confirmation of payment.

The fields that decide what the seller gets paid are added at this stage. The dispatch time and the tracking number are two of them. They matter far more for the payout than on the product page.

3. Right to win a conflict

This right decides whose data stands when two systems disagree. It's the only one of the three that settles anything. It's also the one teams usually leave unset.

Teams commonly give the right to win to whoever has the right to create. Whoever creates an object usually has the weakest data about it a month later.

The seller who opened the page filled in the minimum required fields. The manufacturer of the same goods arrives a year later with complete data. The manufacturer loses because it came second.

Assign rank to classes of sources instead of individual systems. Your 300 sellers form one source class. If you rank sellers one by one, the matrix grows with every seller you recruit.

Who owns each of the 7 objects a marketplace shares between systems?

Table of seven marketplace objects — product page, price and offer, stock level, order, buyer, money balance, document — showing who creates, who enriches, whose write wins, and the single screen for a manual fix.

Map all seven objects in one go. The columns describe roles, and the names of your systems go in later.

1. Stock level, balance, and document

The stock level, the balance, and the document have no screen for a manual fix.

You correct a stock level with a new write from the source. The chapter on inventory synchronization covers how long a stale stock level can last.

You correct a balance with a new correcting entry, and the old entry stays as it is. The chapter on marketplace payment reconciliation covers the entries.

You correct a document by issuing a correction. If someone edits the original, it no longer counts as a document. The chapter on marketplace order documents covers what you produce and keep.

If someone at your company can edit any of these three, check the permissions before you check the data.

2. Order

Orders get duplicated more often than any other object. A mixed cart lands first in the system that collects your own orders. That system splits the cart and opens a second object in the marketplace layer, with its own number.

Two records for one order are normal. The problem starts when no one has written down which number your team uses with the buyer.

The statuses on that order follow a separate rule, settled state by state. The chapter on marketplace order statuses covers them.

The commission rate looks like a setting. Both a system and the commercial contract can set it, and the two can disagree.

The chapter on commission rate drift covers that dispute.

3. Product and offer stored as one record

Check whether each object exists as a separate record in your platform. Some platforms store the product and the offer as one entity.

Two sellers of the same item then create two independent records. You can't assign an owner to a shared page. The platform never creates one.

What happens when two systems write different data into the same field in the same minute?

A hand edit at 11:58 and a seller file at 11:58 in conflict at 12:00, with the four resolution rules: newer write wins, higher-ranked source wins, field removed from the merge, or a human queue.

At 11:58, someone on your team changes the shipping time in the catalog from 5 days to 2. At 11:58, the seller's file arrives with 5 days in the same field. You need to know what the page shows at 12:00, and how you'll find out.

The conflict doesn't need bad faith from anyone. Copies of the same data disagree for four ordinary reasons:

  • Each system understands the field differently.
  • Each system processes the data at a different moment.
  • Each system reads the source differently.
  • Someone makes a plain mistake.

The first three will happen to you for certain. Data synchronization alone doesn't settle the conflict. One of four rules settles it:

  1. The newer write wins. Most integrations use this default, because it needs no decision. The seller's file overwrites your team's correction every time it arrives.
  2. The higher-ranked source wins. You need a list of sources and a decision. After that, the rule settles conflicts on its own.
  3. The field is locked out of the merge. No sync can overwrite a locked field. That also blocks the updates you want from the sync.
  4. The conflict goes to a person's queue. This rule costs the most. Use it where both sides are sometimes correct, because the other three rules give the wrong answer there.

Platforms resolve a conflict either for the whole record or for a single field. At the record level, a worse source replaces the entire object.

This difference matters more than which of the four rules you pick. You'll see it only in a live demo.

How do per-field and per-object conflict resolution compare on a marketplace?

Comparison of 30 fields times 5 source classes equals 150 rules against 10 contested fields times 3 source classes equals 30 rules, plus where per-object and per-field resolution each pay off.

The number of rules you maintain is fields times source classes. A page with 30 fields and five source classes gives you 150 rules. After six months, no one maintains them, and you're back on the default rule.

Turn the calculation around. Ten contested fields and three source classes give you 30 rules. They fit on one page.

You settle them in one meeting and review them once a quarter. People stop reading a matrix that doesn't fit on one page. Rules no one reads go out of date, and your team falls back on the default rule.

Cut the number of sources allowed to write to one object, and leave the fields alone. You can't choose the fields, because your assortment needs them. You can choose how many sources write to each object.

You may have let the panel, the file, the integrator, and the promotion engine all write the price at once. You set it up that way, and you can change it. The cost of resolving conflicts grows faster than the number of parties that write.

What does each level mean for your marketplace?

Resolution per object

Resolution per field

Where it fits (objects)

the document, the balance, the stock level

the product page, the offer

Why it fits there (reason)

the object has one natural author, and everyone else reads it

two parties are right about different fields of the same object

What a worse source does in a conflict (effect)

replaces the entire object

changes one field

Rules you maintain (count)

one per object

fields times source classes, for example 10 times 3 is 30

What it does on the wrong objects (effect)

a worse source overwrites fields that another party owns

extra rules with no return

Every new source that writes to an existing object needs an approved decision. Every integrator, channel, and promotion engine with write access adds a row to a table someone has to approve.

What does a missing single source of truth cost a marketplace?

Three cost calculations on a reference marketplace: 300 hours a year of manual reconciliation, 33 fixes a month that come back after the sync, and 72,000 euro of yearly commission calculated from contested values.

The numbers below come from a hypothetical marketplace. It has 10,000 orders a month, 300 sellers, and 200,000 offers.

The average cart is €1,000, and your commission is 12%. That's €120 for you and €880 for the seller on each order.

1. Hours of support work

Say 1% of orders carry data that two systems disagree about. That's 100 cases a month.

Settling one case means opening two screens, finding out which entry is true, and correcting both. Call it 15 minutes. One hundred cases at 15 minutes each take 25 hours a month, or 300 hours a year.

That's close to two months of one person's work. No one put it in the plan.

2. Fixes made twice

Say one-third of those fixes don't survive the next sync. Then 33 cases a month come back.

That's another 8 hours of work. It's also 33 people who reported the same problem a second time.

3. Commission and payouts on contested data

Say 0.5% of orders close on contested data. That's 50 orders a month.

Fifty orders carry €6,000 of your commission and €44,000 of seller payouts. You calculated both from a number you can't defend. Over a year, the commission alone grows to €72,000.

The amount is the smaller problem. Someone will ask where the number came from. You'll only be able to say that the last system to write it set it.

This cost has no line of its own in the budget. Support, the teams making fixes, and the integration team each pay part of it. The hours alone come to about 400 a year.

What does a single source of truth change in your marketplace?

Once you know who owns each object, you can set the order of your integrations and settle disputes. You'll also see why your reports and your panel often show different numbers.

1. Object map comes before the integration order

Map who governs which object before you decide what to connect first. The chapter on marketplace integrations covers the order of connections.

2. Data synchronization leaves the decision to you

Events, webhooks, and polling give different guarantees. A webhook is a notification one system sends to another when something changes. None of these mechanisms tells you whose data wins, and the chapter on webhook integration covers what each one guarantees.

A repeated message can also turn one object into three. The chapter on idempotency covers that risk.

The matrix of owners is configuration. It goes missing when settings travel between environments, and the chapter on configuration management covers how to carry it across.

3. Disputes need a record of changes

Without a record of who changed which field and when, you can't settle a dispute after the fact. The chapter on audit logs covers that record.

If the decision touched a seller's data, you also owe the seller a justification and a trace. The chapter on P2B regulation covers those duties.

4. Reports count from different copies

A report usually disagrees with the panel because the two count from different copies of the data. The chapter on marketplace analytics covers that gap.

How do you map a single source of truth in one meeting?

The map takes one meeting with the owners of your systems. Work through these steps:

  1. List the seven objects and settle three roles for each: who creates, who enriches, and who wins. That's 21 decisions and about an hour and a half.
  2. Add one column: the single screen where a person may fix a mistake manually. If an object has two screens for fixes, you have a problem to clean up.
  3. Count the source classes that write to each object. If more than three source classes write to one object, reduce the sources or accept the cost of a manual queue.
  4. Write the map down as a table with a review date. Each new integration makes the map out of date.

How do you check a single source of truth with a vendor?

Ask the vendor for a demo on screen for each of these questions:

  1. Can you show me a conflict within the same minute on one field? My person saves one entry, and a file brings another. What does the buyer see, and how do I learn that there was a conflict?
  2. Does conflict resolution work on the whole record or on a single field, and can I set it myself?
  3. Can you show me the screen where my person corrects a field, and what happens to the correction at the next sync?
  4. Can I lock a single field against overwriting, and can I see the list of locked fields?

The answer to the second question matters most. A platform that resolves conflicts only per record makes per-field ownership impossible on the product page.

Which mistakes do operators make with a single source of truth?

Each of these mistakes leaves your data looking tidy on a diagram. The cost shows up in support hours.

1. Source of truth set per system

"System X is the truth" doesn't settle a single real dispute. No system observes every fact about every object.

2. Creator's role attached to the winner's role

Whoever opened the page rules it forever. The best data source may arrive a year later, and it still can't correct its own goods.

3. Two screens for the same fix

Your team does the work twice. One side also ends up with data the other side doesn't know about.

4. New writing source added as a setting

Every integrator with write access raises the number of rules. No one recounts them.

5. Decision written on a diagram

A diagram shows what you meant to happen. The configuration decides what the system does.

The nightly sync follows the configuration and ignores the diagram. Write the decision into the configuration.

What do you still have to settle about a single source of truth?

This chapter doesn't settle disputes inside individual objects. Each of them has its own chapter:

This chapter isn't legal advice. Confirm these families of obligations with a lawyer:

  • The rules for your buyers' personal data. The chapter on marketplace GDPR covers the roles.
  • Your duties to a seller when a decision touches their data. The chapter on P2B regulation covers them.
  • How long you keep documents and in what form. The chapter on marketplace order documents covers retention.

Your systems differ from the example in this chapter. Put in your own order volume and your own handling time for one discrepancy.

Summary: Who owns which data on a marketplace?

A single source of truth gives every object one owner and one screen for a manual fix. The fix also survives the next sync.

Separate the right to create, the right to enrich, and the right to win a conflict. Rank classes of sources, and limit the number of sources that write to one object. You correct the stock level, the balance, and the document only with a new entry.

An object without one screen for a manual fix has no real owner. Its data is whatever the last sync wrote.

Ask a vendor to show you a conflict on one field within the same minute. Building a marketplace where every object has one owner and one screen for corrections?

Frequently asked questions on a single source of truth

What is a single source of truth?

A single source of truth is an arrangement in which each piece of data is created and corrected in one place, while other systems only read copies. On a marketplace, it covers seven objects from the product page to the document. Copies are fine, but each object has only one place where it's edited.

What is the difference between a source of truth and a system of record?

A system of record is the authoritative system for one type of data, and a source of truth is the arrangement that gives every type of data such a place. The ERP can be the system of record for invoices, and the seller panel for prices. A single source of truth means every object has exactly one system of record.

How does master data management relate to a single source of truth?

Master data management is the discipline of keeping core business data consistent across systems, and a single source of truth is its usual goal. It covers rules, owners, and processes for data such as products and customers. On a marketplace, the hardest part is that sellers create most of that data.

Ready to build?

We build marketplaces that give every product, price, and order one owner and one screen where your team corrects it.