- Atlas
- Computer Science
- Data Modeling
Data Modeling
Data modeling is the work of deciding, in advance and on purpose, what things a database will hold, what facts about them matter, and how those facts connect.
11 frameworks, from 1966 to today · Databases · Computer Science
- Hierarchical database model 1966-1985
- Network model 1969-1985
- Relational model 1970-Present
- Database normalization 1971-Present
- Entity-relationship model 1976-Present
- Semantic data model 1976-1995
- Object-oriented data modeling 1985-2005
- Corporate information factory 1992-2010
- Dimensional modeling 1996-Present
- NoSQL data modeling 2006-Present
- Data contracts and schema registries 2018-Present
Overview
Data modeling is the work of deciding, in advance and on purpose, what things a database will hold, what facts about them matter, and how those facts connect1. The output is rarely a program; it is a description — boxes and arrows, tables and keys, a JSON schema, a diagram in a wiki — from which databases, programs, reports and interfaces are then built. What is at stake is everything downstream: a model that names the wrong things, or refuses to allow a fact to change, produces systems that are expensive to correct and sometimes wrong in ways nobody notices. The history of the field is a sequence of attempts to find a description precise enough for a machine and natural enough for the people who know the business, and each attempt was provoked by the failure of the one before.
Files, hierarchies, and the first database models
Before the 1960s, "data modeling" mostly meant laying out records on tape or disk: fixed fields, fixed lengths, and programs that knew exactly where each byte lived. The arrival of direct-access storage made something new possible — a store that programs could navigate rather than scan — and two competing answers to how to describe it dominated the decade.
The hierarchical data model, most famously realized in IBM's Information Management System (IMS), released in the late 1960s for the Apollo program's bill-of-materials data, organized records as a tree. Each parent could have many children; each child had exactly one parent2. For genuinely nested data — a company's divisions, departments and employees; a parts explosion — this matched the world. Its limitation was equally structural: a part used in two assemblies had to be stored twice or linked awkwardly, and a query "find all parts supplied by X" had to climb the tree from a fixed starting point.
The network data model, codified by the Conference on Data Systems Languages (CODASYL) Data Base Task Group report of 1969 and implemented in systems such as IDMS and IDS, generalized the tree to a graph. Records were connected by named sets, each with one owner record and many member records, and a record could be a member of several sets3. This solved the duplication problem but pushed the burden onto programmers: to ask a question you wrote a navigation program that walked pointers from record to record, and that program encoded the physical layout. Change the model and the programs broke. Both models shared a deeper assumption — that the description of data and the storage structure were essentially the same thing — and this is the assumption the next idea attacked.
The relational model: data described by values, not pointers
In 1970 Edgar F. Codd, a mathematician working at IBM's San Jose research laboratory, published "A Relational Model of Data for Large Shared Data Banks." Codd's claim was radical in its simplicity: describe all data as relations — tables of rows and columns — and let users ask questions in a declarative language that names the data they want, without any knowledge of how it is stored or reachable4. A relation is just a set of tuples; there are no pointers and no prescribed access paths4. Anything expressible in the network model, Codd argued, could be expressed relationally, and the description would be independent of the machine.
The model's practical breakthrough came with the query language. Codd proposed a relational calculus in the early 1970s; IBM's System R project, and in parallel the University of California, Berkeley's Ingres project, built working prototypes, and the language that emerged from System R — Structured English Query Language, later SQL — became the interface through which most of the world would ever touch a database. The commercial turning point was Oracle's first release in 1979, followed by IBM's SQL/DS and DB2 in the early 1980s. The relational model did not merely win; it became the default assumption of the industry for the next three decades5.
What made it persuasive was not elegance alone. A declarative query could be optimized by the system — the same question could be answered by different physical strategies, and the machine chose. That separation of logical description from physical execution is the founding idea of modern data modeling, and almost every later development in this history is either an extension of it or a reaction against its constraints.
Normalization: designing tables that behave
Once data lived in tables, a new question appeared: which tables? A badly designed table — customer address repeated on every order line — caused update anomalies, where changing one fact required changing many rows and risking inconsistency. Codd answered with normalization theory, beginning in 1971 and refined through the decade. The idea was to define, formally, the dependencies among attributes and then decompose tables so that each fact was stored once6.
A functional dependency is the statement that one set of attributes determines another: given a customer number, the customer's city is fixed. From such dependencies Codd and later theorists derived normal forms — first, second, third — each a condition on how dependencies are arranged7. Third normal form, roughly, says every non-key attribute depends on the whole key and nothing but the key7. A landmark clarification came from Ronald Fagin's work on multivalued dependencies and fourth normal form in the late 1970s, and further normal forms followed. The practical payoff was concrete: a schema in third normal form could not produce the anomaly where a customer's address is updated in one row and left stale in another7.
Normalization gave data modeling its first genuine method — a procedure with a theory behind it — and it remains the backbone of transactional database design. But it was also a theory about avoiding redundancy, not about capturing meaning. Two schemas could both be perfectly normalized and describe the business differently, and nothing in the normal forms said which was right.
Semantic models and the entity-relationship diagram
The 1970s produced a wave of semantic data models that tried to close that gap by building meaning into the description itself. The best known is Peter Chen's entity-relationship model, published in 19768. Chen proposed that a database be designed by first identifying entities — things that exist independently, such as a customer or a product — and relationships among them, with attributes attached to each, and then mapping that conceptual picture onto relational tables. The ER diagram, boxes for entities and diamonds for relationships, became and remains the most widely used picture in the field: it is how designers talk to domain experts who will never read a normal form.
Other semantic models explored related territory: the Semantic Data Model of Michael Hammer and Dennis McLeod (1981), which introduced the idea of a class with subclasses inheriting attributes; SDM's successor and the functional data model of David Shipman; and work on generalization and aggregation as modeling primitives. Their shared conviction was that a data model should express what the designer believes about the world, not just what fits the tables1.
Dimensional modeling: designing for questions, not for storage
Meanwhile a different pressure was building. By the late 1980s organizations had accumulated operational databases optimized for recording transactions, and analysts wanted to ask aggregate questions — sales by region by month by product — that these schemas answered slowly and awkwardly. Bill Inmon articulated the data warehouse in the early 1990s as a subject-oriented, integrated, time-variant store separate from operations, and Ralph Kimball supplied the design method that made it buildable: dimensional modeling.
Kimball's approach, laid out in The Data Warehouse Toolkit (1996), inverted the normalization instinct. Instead of decomposing to avoid redundancy, design around the business process being measured, with a central fact table holding numeric measures (quantity sold, revenue) and dimension tables describing the context — product, customer, time, store9. A star schema is one fact table surrounded by dimensions; a snowflake schema normalizes the dimensions further910. The method accepted redundancy in exchange for queries that were simple to write and fast to run. Kimball's dimensional bus architecture and Inmon's corporate information factory — an enterprise-wide normalized warehouse feeding dependent data marts — were the two poles of warehouse design debate through the late 1990s, and many organizations ran hybrids.
Objects, and the trouble with impedance
As programming moved to object-oriented languages in the 1980s and 1990s, modelers faced a mismatch: programs thought in objects with identity, encapsulation and inheritance; databases thought in tables of values. Object-oriented data modeling addressed this directly. Object database systems and the Object Data Management Group's standards gave objects persistent identity and allowed references between them, and modeling notations such as the Unified Modeling Language's class diagrams became the standard way to draw a domain model.
Object-oriented databases found niches in engineering and telecommunications but never displaced relational systems. The more consequential outcome was the object-relational hybridization: SQL:1999 added user-defined types, inheritance and complex values to the standard, and relational products absorbed enough object thinking to blunt the need for a separate class of database. The impedance mismatch was managed rather than solved, and it remains a live design tension wherever an application's object model and its storage schema diverge.
NoSQL: modeling for scale and shape
The late 2000s brought a shock to the relational consensus. Web-scale systems found that a single relational schema with strict normalization and joins was difficult to spread across hundreds of commodity machines, and that some data — a document, a social graph — did not decompose naturally into tables. NoSQL data modeling answered with models built around access patterns rather than around normalized facts.
The key-value store modeled data as a map from key to opaque value; the document model stored nested JSON-like structures with the whole document as the unit of retrieval; the wide-column model, popularized by Google's Bigtable paper (2006) and Cassandra, organized data into rows with sparse, dynamically named columns; the graph model stored entities as nodes and relationships as edges with their own attributes, which made traversal queries natural. The modeling discipline changed accordingly: instead of asking "what are the entities and dependencies," the NoSQL designer asks "what queries will the application run, and how do I lay out data so each is a single lookup?" Denormalization, duplication and precomputation became legitimate tools, with consistency handled by the application.
The commercial rise of these systems, and the eventual emergence of NewSQL systems that recombined SQL and horizontal scale, made the field plural. Relational, document, graph and columnar models now coexist in the same architecture, and "polyglot persistence" — choosing a model per workload — is an accepted practice.
Contracts, registries, and the governance turn
The most recent shift is less a new way to draw data than a new way to enforce agreement. As systems multiplied and data flowed between teams, the model stopped being an internal design artifact and became an interface between producers and consumers. Data contracts formalize this: the schema, semantics, quality expectations and ownership of a published dataset are agreed in writing, and breaking changes require a versioned negotiation. Schema registries, such as those built around Apache Avro and Confluent's Schema Registry, make it mechanical — producers register their schema, consumers fetch compatible versions, and the registry refuses changes that violate declared compatibility rules. The lineage is direct: this is Codd's insistence on describing data independently of programs, applied across organizational boundaries instead of within one system.
Where the field stands
Today the main approaches all descend from the turning points above. Entity-relationship modeling and normalization remain the default for transactional systems; dimensional modeling remains the default for analytics, though columnar storage and lakehouse architectures have blurred the warehouse boundary; document, graph and key-value models are standard options where access patterns justify them; object-relational mapping tools mediate between object models and tables; and contract-and-registry tooling is extending the discipline to streaming and inter-team data exchange. The open questions are the old ones in new clothing: how to keep a model faithful to a changing business, how to reconcile a conceptual model with several physical stores, and how to describe semantics — meaning, not just structure — well enough that machines can validate it. Semantic modeling was an unfinished project in the 1970s, and it is unfinished still.
References
- Data modeling (Overview, Semantic data modeling), Wikipedia
- Hierarchical database model, Wikipedia
- Network model (History), Wikipedia
- Relational model, Wikipedia
- Database (History), Wikipedia
- Database normalization, Wikipedia
- Third normal form, Wikipedia
- Entity–relationship model, Wikipedia
- Star schema, Wikipedia
- Snowflake schema, Wikipedia
The frameworks of Data Modeling
Each framework is a way of working the field has used: when it held, and the question it answers.
- 1966-1985
Hierarchical database model
How should nested data be stored and navigated?
- 1969-1985
- 1970-Present
- 1971-Present
Database normalization
How should tables be designed to avoid anomalies?
- 1976-Present
Entity-relationship model
How can entities and relationships be modeled conceptually?
- 1976-1995
- 1985-2005
Object-oriented data modeling
How should objects be stored in databases?
- 1992-2010
Corporate information factory
How should an enterprise warehouse be structured?
- 1996-Present
- 2006-Present
- 2018-Present
Data contracts and schema registries
How can data schemas be enforced across systems?
How the ideas connect
Each arrow runs from an earlier idea to the later one it shaped. The list below says what passed between them.
Network model grew out of Hierarchical database model
The network model generalized the hierarchical tree to a graph, allowing a record to have multiple owners. The CODASYL Data Base Task Group report of 1969 defined the network model as a direct extension of hierarchical structures.
Carried by CODASYL Data Base Task Group; Charles Bachman.
Relational model reacted against Hierarchical database model
Codd's relational model was explicitly framed as an attack on the hierarchical and network models' coupling of logical description to physical storage. He argued that data should be described by values, not pointers, and that users should not need to know the storage structure.
Carried by Edgar F. Codd; A Relational Model of Data for Large Shared Data Banks (1970).
Relational model reacted against Network model
Codd presented the relational model as a replacement for the pointer-based network model, arguing that anything expressible in the network model could be expressed relationally without navigation programs. The relational model's declarative querying was a direct rejection of the network model's procedural navigation.
Carried by Edgar F. Codd; A Relational Model of Data for Large Shared Data Banks (1970).
Entity-relationship model influenced by Relational model
Chen's entity-relationship model was designed as a conceptual modeling layer that could be mapped onto relational tables, and it assumed the relational model as its target implementation. The ER model provided a higher-level design notation for relational databases.
Carried by Peter Chen.
Semantic data model reacted against Relational model
Semantic data models arose in the 1970s as a reaction to the relational model's lack of constructs for capturing meaning, such as classes, inheritance, and aggregation. They argued that a data model should express what the designer believes about the world, not just fit tables.
Carried by Michael Hammer; Dennis McLeod.
Object-oriented data modeling reacted against Relational model
Object-oriented data modeling emerged in the 1980s as a response to the impedance mismatch between object-oriented programming and relational tables. It rejected the relational model's flat, value-based structure in favor of objects with identity, encapsulation, and inheritance.
NoSQL data modeling reacted against Relational model
NoSQL data modeling arose in the mid-2000s as a reaction against the relational model's constraints, particularly its fixed schemas and vertical scaling, in favor of schema-less, distributed data stores for web-scale applications. It rejected the relational model's assumption of a single structured schema.
Dimensional modeling reacted against Database normalization
Dimensional modeling rejected the goal of eliminating redundancy through normalization, instead designing around business processes with denormalized dimension tables. Kimball explicitly traded normalization for query simplicity and performance.
Carried by Ralph Kimball; The Data Warehouse Toolkit (1996).
Semantic data model rival of Entity-relationship model
The entity-relationship model and the semantic data models of the late 1970s were contemporary attempts to build meaning into conceptual database design. They competed to provide richer modeling primitives than the relational model alone.
Carried by Peter Chen; Michael Hammer; Dennis McLeod.
Object-oriented data modeling influenced by Semantic data model
Object-oriented data models drew on semantic modeling concepts such as classes, subclasses, inheritance, and aggregation that had been developed in the semantic data models of the late 1970s and early 1980s. These constructs were incorporated into object-oriented database systems.
Carried by Michael Hammer; Dennis McLeod.
Dimensional modeling rival of Corporate information factory
Inmon's corporate information factory, an enterprise-wide normalized warehouse feeding dependent data marts, competed with Kimball's dimensional bus architecture as the dominant approach to data warehouse design in the 1990s. The two poles framed the warehouse design debate.
Carried by Bill Inmon; Ralph Kimball.
Data contracts and schema registries reacted against NoSQL data modeling
Data contracts and schema registries emerged as a response to the schema chaos and lack of enforcement in NoSQL and streaming data pipelines, reintroducing formal schema definitions and validation at the boundaries between producers and consumers. They addressed the problems of unmanaged schemas that NoSQL modeling had encouraged.
Beyond the field
Where Data Modeling's ideas came from in other fields, and what they led to there: the strongest 12 of 61 links.
Network model provoked Relational model in Database Theory
Codd presented the relational model explicitly as an alternative to the pointer-based network (CODASYL) model, arguing that data independence required abandoning navigation by links. The relational model defined itself against the network model's record-at-a-time access.
Carried by Edgar F. Codd; A Relational Model of Data for Large Shared Data Banks (1970).
Relational model led to Database normalization in Database Theory
Normalization was developed directly out of Codd's relational model, using functional dependencies over relations to define first, second and third normal forms. It is a refinement within the relational framework rather than an independent doctrine.
Carried by Edgar F. Codd; Further Normalization of the Data Base Relational Model (1971).
Relational model reacted against Navigational data models in Nosql Systems
Codd presented the relational model as a deliberate rejection of the pointer-based navigational (hierarchical and network) models, arguing that application programs should be independent of physical storage structures. The relational approach defined itself against navigational data models.
Carried by Edgar F. Codd; A Relational Model of Data for Large Shared Data Banks (1970).
Relational model reacted against Navigational database in Databases
The relational model was framed by Codd as an attack on navigational databases, whose pointer-following access he criticized for tying programs to physical structure. The relational approach defined itself by rejecting that navigational premise.
Carried by Edgar F. Codd; A Relational Model of Data for Large Shared Data Banks (1970).
Database normalization grew out of Relational model in Databases
Normalization theory was formulated within and grew out of the relational model, using relations and functional dependencies as its basic objects.
Carried by Edgar F. Codd.
Entity-relationship model grew out of Relational model in Databases
Chen's ER model was defined against and in terms of the relational model, with ER schemas mapped to relational tables. It is a conceptual refinement derived from relational theory.
Carried by Peter Pin-Shan Chen.
Entity-relationship model grew out of Relational model in Database Theory
The entity-relationship model grew out of Codd's relational model, adopting its treatment of data as sets of records while adding a conceptual entity/relationship layer.
Carried by Peter Pin-Shan Chen; Edgar F. Codd.
Entity-relationship model grew out of Relational Model in Data Science
Chen's entity-relationship model was built on the relational model, translating ER diagrams into relations and using relational theory as its formal target. The ER model is a conceptual layer derived from relational ideas.
Carried by Peter Pin-Shan Chen; The Entity-Relationship Model (1976).
Entity-relationship model influenced Functional Requirements for Bibliographic Records in Knowledge Organization
FRBR was built as an entity-relationship model, adopting Chen's ER formalism to represent works, expressions, manifestations and items and their relationships.
Carried by Peter Pin-Shan Chen.
Semantic data model grew out of Relational model in Databases
Semantic data models were developed as refinements of the relational model, retaining relations while enriching them with semantic structure.
Carried by Peter Pin-Shan Chen.
Semantic data model grew out of Relational model in Database Theory
Semantic data modeling grew out of the relational model by adding abstraction constructs (entities, generalization, aggregation) to flat relations.
Carried by Peter Pin-Shan Chen; Michael Hammer; Dennis McLeod.
Semantic data model grew out of Relational Model in Data Science
Semantic data models such as the entity-relationship model and its successors were built as extensions of the relational model, adding semantic constructs on top of relations.
Carried by Peter Pin-Shan Chen.

Data Modeling is a planet in Nousfarer
Its city has a tower for each of these 11 frameworks. Land, walk in, and climb one concept at a time.
Land on Data ModelingRelated fields
Fields its ideas are linked to
- Databases 16 links
- Database Theory 12 links
- Data Science 9 links
- Nosql Systems 8 links
- Big Data Processing 4 links
- Systems Analysis And Design 3 links
- Business Analytics 2 links
- Model Based Systems Engineering 2 links
- ML Systems 1 link
- Knowledge Organization 1 link
- Programming Paradigms 1 link
- Requirements Engineering 1 link