Item count is the wrong measure

A shop with three hundred items can manage happily with a spreadsheet for years. Another with eighty items can struggle with one. The difference lies not in size but in the number of dependencies. Anyone running a single shop in one language and maintaining the data themselves has one source and one recipient.

Things look different once the same data is needed in several places. Take a cosmetics retailer selling through its own shop, on a marketplace and to two resellers who expect a master data file. Each product then exists four times. If a formulation changes, and with it the ingredient list, that change has to reach four places. If someone forgets one, an outdated detail remains somewhere.

Error rates therefore do not grow with the number of items. They grow with the interplay of items, channels, languages and editors. One additional channel often has a bigger effect than doubling the range. Anyone watching only the item count tends to notice the limit too late.

What product data management actually covers in a small shop

Product data management answers three questions: where product information originates, who changes it and how it reaches the channels. It covers more data than the shop shows. Besides title, description and price, there are article numbers, GTIN codes, weights, fill quantities, unit prices, variants, translations and image assignments. In cosmetics, ingredients, usage instructions and warnings come on top.

A PIM system, short for product information management, is software that holds this data in one place. The shop, marketplaces and export files are all fed from it. The shop backend then becomes a recipient rather than a source. That reversal is the core of a PIM, not its interface or the number of its features.

A spreadsheet can play the same role as long as it remains the only source. The trouble starts when a second version of the truth appears next to it. Usually that is the shop backend, where someone quickly corrects a price without touching the spreadsheet.

How the second version of the truth emerges

Hardly any retailer chooses two data sources on purpose. It happens on the side. A typo is spotted on a Friday evening and fixed directly in the shop. A promotion needs an amended text that only exists in the backend. A few months later, nobody knows for certain which version is right.

It becomes visible at the next import. Someone uploads the spreadsheet to the shop again to add twenty new products. In doing so, the import overwrites the corrections of recent months. On Monday a customer reports that the fill quantity on the product page does not match the packaging. Or a marketplace blocks an item because a mandatory field is missing.

The mechanism behind this is simple. Every change made outside the leading source is a delayed error. It does not appear immediately but at the next synchronisation. That is why these problems seem random, even though they arise systematically.

How to tell the spreadsheet is reaching its limit

The tipping point announces itself long before anything serious goes wrong. A few signs can be checked directly within your own business.

Several channels with their own requirements. Marketplaces demand their own categories, attributes and formats. Anyone maintaining extra sheets or columns for them is running several data models side by side. Every change then has to be translated into each of these models, by hand.

Several people edit the same data. Spreadsheets offer little in the way of approvals or field-level permissions. Version histories exist, but they show changed cells, not changed products. Working out who adjusted the price of a variant, and when, takes real effort.

Variants and translations. Every size, scent or language multiplies the rows. A change to the base product has to be carried through to every variant. That is where most discrepancies arise.

Corrections take longer than new listings. If creating a product is quick but changing one takes half a day, the data setup is the problem, not the way people work.

One question sums up these signs: how long does it take for an amended detail to be correct in every channel, and who knows for certain afterwards that it is? If the answer is hours, or nobody really knows, the limit has been reached.

When a PIM is not worth it for a long time

A PIM system is not an upgrade every shop needs eventually. It brings its own costs: licence or hosting, implementation, interfaces to the shop and marketplaces, and ongoing maintenance of those connections. For many small retailers, this effort outweighs the benefit for years.

One channel, one language, few editors. Here the shop backend itself is the best source. An extra spreadsheet or a PIM only adds another handover where errors can creep in.

A range that rarely changes. Anyone launching new products a few times a year and otherwise adjusting little gains not much from a PIM. The set-up simply never pays for itself.

Unclear data. Anyone who does not know today which fields a product needs will move the muddle into a more expensive system. A PIM enforces a data model, but it does not design one.

An intermediate step is often enough. The spreadsheet is declared the sole source, edits in the backend are no longer allowed, and a fixed import routine replaces manual uploads. This costs little and removes the second version of the truth. How to automate routines like this with a sense of proportion is covered in How Much Automation a Small Team Really Needs.

What a PIM does not solve

A PIM is often expected to improve data quality. It does so only indirectly. It makes missing fields visible and can enforce mandatory details. Whether a description is good or an ingredient list correct, it does not check.

Responsibility also remains an organisational question. If nobody is accountable for complete product data, the PIM will be as patchy after a year as the spreadsheet was before. It simply looks tidier, which makes the gaps harder to notice.

Finally, a PIM shifts part of the effort rather than removing it. The interfaces need looking after. If a marketplace changes its attribute requirements, someone has to adjust the mapping. This work does not disappear; it only becomes easier to plan.

The first step is a data model, not software

The most sensible first step does not depend on whether a spreadsheet or a PIM comes out at the end. It consists of writing down the data model. Which fields a product has, which of them are mandatory, which values are allowed, and which channel needs which field. This list alone often reveals where data is maintained twice today.

Next comes deciding which source leads. For every field there is exactly one place where it may be changed. Stock levels often come from the inventory system, texts from the spreadsheet or the PIM. What matters is not that everything sits in one place. What matters is that every field has a clear origin.

If the decision falls on a PIM, implementation is best started with part of the range and a single channel. For a while, the output of shop and PIM is compared before the PIM takes the lead. Only once the data in that channel is right do further channels follow.

Product data management remains an ongoing task

Spreadsheet or PIM, product data is never finished. Formulations change, marketplaces adjust their requirements, new channels are added. Once it is settled where data originates and who is responsible for it, these changes can be absorbed without unsettling the shop every time.

How we build shop architectures and the data flows behind them is described under Services.