
A data model describes what the application considers to be true. It decides which facts can exist independently, which relationships connect them and what changes can be made without creating contradictions. The arrangement of a screen is only one view of those facts. Unfortunately, early prototypes often store information in almost the same order in which it appears on a screen. This can be convenient for the first version, but it becomes difficult when the same information appears on another screen or begins to change at a different rate.
Look for independent identities
Consider a catalog item displayed with a title, a category name and a short description in another language. A prototype may store all of these fields together in one record. The record then includes the words that appear in the card. If twenty items belong to the same category, twenty records contain the category name. Renaming the category requires finding every copy. A forgotten copy is not merely a formatting inconsistency: it may lead a visitor to believe that the catalog actually contains two different categories.
First establish which concepts have their own identity. A category can exist before any item is assigned to it, and it can change its label without ceasing to be the same category. Give it a stable identifier and store its label in one authoritative place. The item still has its own identifier and its own independent attributes. An association between two identifiers represents membership. Now renaming category twenty-five is one change to a category record, while moving an item is a change to its membership.
Describe the cardinality of each relationship
It is useful to ask how many related records may exist before deciding how to represent them. Some catalogs assign each item to exactly one category. Others allow any number of categories, including none. For the first design, a reference from the item to the category might describe the complete relationship. For the second, a separate membership record containing an item identifier and a category identifier may be appropriate. A uniqueness rule on that pair can prevent an item being assigned to the same category twice unintentionally.
Do the same work for translation records. If an item has localised titles and descriptions, each translation can reference the item while identifying its language. A product need not have every language represented; the absence of a translation may be a meaningful state. A rule requiring one record per combination of item and language prevents conflicting text being selected from two equally authoritative records. If translated content needs review before publication, the translation may also have its own lifecycle and status rather than always inheriting the original item's status.
Understand what a missing value means
Related reading: Making documentation part of software delivery.
A missing category might mean that an editor has yet to classify an item. An item with a category deliberately removed has a different history, although its current membership may be identical. For translation, a missing record might mean that the language is not supported for that item. A present translation with an empty description is another condition. The application must decide how each case behaves on the site. Storing several conditions under one empty string can leave the display logic unable to make the necessary distinction.
Avoid inventing additional fields for hypothetical differences that no real workflow needs. There is a tension between modeling meaningful distinctions and creating an exhaustive representation of every imaginable state. The appropriate model can be guided by actual operations. If editors need to identify untranslated items separately from unfinished translations, the difference deserves explicit representation. If the catalog treats both cases exactly alike and has no legitimate requirement to retain their distinction, a simpler representation may be sufficient.
Write operations against the proposed model
A diagram with correctly named entities is a useful starting point, but try performing realistic operations in it. Create a new item that has no translation. Attach it to two existing categories. Add a translation in one language, then update its text. Rename one category, remove the item from another and retrieve the item as a public card. These examples quickly demonstrate which identifiers are needed, where optional values appear and whether several writes must be treated as one logical operation.

Deletion deserves particular care. If the category is removed, should the membership records disappear or should removal be prohibited until an editor has reassigned the items? A retired category that still belongs in historical reports might need another approach. Similarly, removing an item may require removing its translations from the public catalog, but retaining selected historical information. Determine these behaviors rather than adopting a blanket rule that all linked information must be deleted. The model should support the decision the application actually promises to its users.
Keep read models convenient without confusing ownership
Separate authoritative records do not require the frontend to assemble information by making a request for every title and category. A catalog operation can retrieve the required facts and return a composed view designed for a card. It might contain the item identifier, its current title in the chosen language, the category labels and the preview address. That structure is convenient for rendering, but it need not become a second authoritative source of these facts. Changing a label in the category record should change the next view of the item.
Some applications benefit from storing a derived representation to make common reads faster. For example, periodically building a public catalog snapshot may avoid a series of database operations for every page request. In this case duplication is deliberate, not accidental. Document what generates the snapshot, which authoritative records it depends on, when it expires or changes, and how it can be rebuilt. If a change to the source can leave the project indefinitely serving a stale label, the convenience of the duplicate representation comes with a substantial maintenance cost.
Plan migrations as actual transformations
Suppose the existing catalog stores category names as text in each item. Introducing category records means deciding which old values represent the same category. Capitalization or trailing spaces might have created several variants of a label. The migration cannot simply treat every distinct string as a separate identity if the business intends those variants to be equivalent. Start by examining the data, document the mappings and establish a policy for ambiguous names. Preserve the existing item identifiers so related content still refers to the same items.
Build a trial conversion on a representative copy of the data. Count the items, translations and resulting memberships and compare a selection of old and converted cards. Verify that no item disappeared because a category name was blank or unrecognized. Check that editing a converted record now changes the expected authoritative source. A useful migration plan also explains what happens if old and new representations need to coexist during transition. If both are writable, decide which representation owns changes and how the other remains consistent.
Measure the model by the cost of everyday work
Once a proposed model handles the main operations, compare it to the simpler alternatives. Which facts would need changing when a category is renamed? How many places would have to agree if a translated description were corrected? Can a typical catalog page be generated without excessive work? Will a maintainer understand the difference between a stored field and a derived display value? These questions are more useful for evaluating the model than the number of entities alone. A small and well-understood collection of records is preferable to both a sprawling speculative schema and a tightly coupled document that hides independent relationships.
An evolving application will eventually discover requirements its initial model did not anticipate. A sound design makes those changes understandable because the existing facts, their owners and their relationships are clear. It is easier to add an attribute to an identified entity than to decide whether twenty inconsistent copies of a label describe one fact or twenty facts. Establish the model around today's real relationships, verify it against concrete examples and adjust it openly when those relationships change.
Explore the implementation area: Backend development.


