Data Modeling
Data modeling defines the structure, relationships, and constraints that organize data within a system. It produces schemas — conceptual, logical, and physical — that determine how information is stored, queried, and maintained across databases and analytics platforms.
itData engineering and analytics | OpenSkills.info
Course pathWalk it in order
Look it upDip in anytime
Go furtherLeaves this page
Don't Panic
Don't Panic — Data Modeling
Data modeling is the work of deciding what data means before a system starts politely filing guesses in a database. The database is very good at storing what it receives. It is considerably less gifted at noticing that three teams used the word Customer for three different things.
Start with the useful thought that a model is a set of promises. A promise says what one record represents, how it is identified, what it may relate to, and which states must be rejected. Tables, documents, and diagrams are the envelopes carrying those promises. They are not the promises themselves, which saves a surprising number of meetings from being replaced by more decorative meetings.
The first useful distinction is between a conceptual model, a view of the important domain concepts, a logical model, which adds attributes and relationship rules, and a physical model, which chooses tables or collections, types, keys, and constraints for one technology. These are viewpoints, not ceremonial paperwork. Their job is to stop a database-specific choice from masquerading as a business rule.
Two ideas do most of the heavy lifting. Identity answers how one persistent thing remains distinguishable from another, even when a tempting value such as an email address changes. Grain says exactly what one record means. If one row means one product line on one accepted order, an order total does not become a line value merely because it fits in a column. It can be copied and summed later, at which point arithmetic will cheerfully certify the wrong answer.
Relationships need their own small interrogation. How many records may participate? Must one exist? Does the association carry data? Order Line exists because quantity and sale price describe one product on one order, not Order or Product alone. That is the moment where a line in a diagram becomes a decision someone can test.
The next surprise is that normalization and denormalization are not rival teams with matching T-shirts. Normalization reduces repeated facts and the chance that their copies disagree. Denormalization deliberately groups or repeats data for a measured access need. The second choice is valid only when the query, duplicated facts, and synchronization behavior are all named. Otherwise it is an accidental second source of truth wearing a performance hat.
The rest of the course turns those promises into working checks. The Introduction explains the levels, keys, constraints, workloads, and limits. Slides condense their relationships. The Cheatsheet gives you review questions and design records. The practice exercise asks you to model an order process and prove what invalid writes your design rejects. Start there when the topic stops being a diagram and starts being a system.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://www.ibm.com/think/topics/data-modeling
Supports
- Data models provide a consistent way to define and manage data resources
- Conceptual models describe high-level entities, relationships, constraints, and business rules
- Logical models add attributes and formal relationships without technical system requirements
- Physical models specify implementable schemas, keys, and database-specific properties
- Modeling proceeds through entities, attributes, relationships, keys, normalization, validation, and iterative refinement
- Relational, entity-relationship, and dimensional models serve different design purposes
- https://learn.microsoft.com/en-us/previous-versions/troubleshoot/microsoft-365/microsoft-365-apps/access/database-normalization-description
Supports
- Normalization organizes tables and relationships to reduce redundancy and inconsistent dependencies
- Repeated facts create storage and maintenance problems when updates must agree across copies
- First normal form removes repeating groups and identifies related sets with primary keys
- Second normal form separates values that apply to multiple records and relates them with foreign keys
- Third normal form removes fields that do not depend on the record key
- Normalization can require additional tables and practical designs may balance it against performance
- https://www.postgresql.org/docs/current/ddl.html
Supports
- Relational data is stored in tables
- Physical data definition includes tables, defaults, generated columns, constraints, schemas, partitioning, and related database objects
- https://www.postgresql.org/docs/current/ddl-constraints.html
Supports
- Check constraints enforce Boolean expressions on accepted row values
- Not-null constraints require present values
- Unique constraints enforce uniqueness for a column or column combination
- Primary keys identify rows with unique and non-null values
- Foreign keys maintain referential integrity between related tables
- An associative table with foreign keys can implement a many-to-many relationship
- Referential actions define behavior when referenced rows are deleted
- https://www.mongodb.com/docs/manual/data-modeling/best-practices/#link-related-data
Supports
- Document models can link related data through embedding or references
- Embedding fits related data that is accessed together and remains bounded
- References fit independently queried, independently changing, unbounded, or complex relationships
- Schema design should follow application access patterns rather than copy a relational shape mechanically
- https://www.mongodb.com/docs/v8.2/applications/data-models-relationships/
Supports
- MongoDB models relationships by embedding related data or connecting separate documents with references
- Official examples cover one-to-one, one-to-many, many-to-many, and tree relationships
- https://learn.microsoft.com/en-us/power-bi/guidance/star-schema
Supports
- Star schemas classify model tables as dimensions or facts
- Dimension tables describe business entities and support filtering and grouping
- Fact tables store observations or events and values for summarization
- Dimension keys and values determine fact dimensionality and granularity
- Fact tables should load data at a consistent grain
- Analytical model design can differ from normalized source structures
- https://dl.acm.org/doi/10.1145/362384.362685
Supports
- Codd published A Relational Model of Data for Large Shared Data Banks in 1970
- https://www.computerhistory.org/collections/catalog/102657876
Supports
- The CODASYL Database Task Group report documented the network database approach in 1971
- https://dl.acm.org/doi/10.1145/320434.320440
Supports
- Peter Chen published The Entity-Relationship Model in 1976
- https://www.iso.org/standard/76583.html
Supports
- SQL was standardized for relational database language in 1986
- https://dl.acm.org/doi/book/10.5555/103101
Supports
- Codd published The Relational Model for Database Management in 1990
- https://www.kimballgroup.com/1997/08/a-dimensional-modeling-manifesto/
Supports
- Kimball published A Dimensional Modeling Manifesto in 1997
- Dimensional modeling distinguishes fact tables and dimension tables for analytical access
- https://research.google/pubs/bigtable-a-distributed-storage-system-for-structured-data/
Supports
- Google published Bigtable in 2006
- Bigtable stores structured data in a distributed sparse multidimensional sorted map
- https://www.allthingsdistributed.com/files/amazon-dynamo-sosp2007.pdf
Supports
- Amazon published Dynamo in 2007
- Dynamo is a highly available key-value storage system that uses partitioning and replication
- https://www.quest.com/products/erwin-data-modeler/
Supports
- erwin Data Modeler supports enterprise data modeling
- https://www.oracle.com/database/sqldeveloper/technologies/sql-data-modeler/
Supports
- Oracle SQL Developer Data Modeler supports logical, relational, and physical data modeling
- https://lucid.co/lucidchart
Supports
- Lucidchart provides collaborative diagramming
- https://dbdiagram.io/
Supports
- dbdiagram.io provides code-based database diagrams using DBML
- https://www.sqldbm.com/
Supports
- SqlDBM provides collaborative conceptual, logical, and physical data modeling
