ER Diagram Notation Guide: Crow's Foot, Chen & UML Compared

What Is an ER Diagram?

An Entity-Relationship (ER) diagram is a visual representation of a database schema. It shows the entities (tables) in a database, the attributes (columns) of each entity, and the relationships (foreign keys) between them. ER diagrams are the standard communication tool between developers, database administrators, and domain experts when designing or documenting a database.

Three major notation styles have emerged over the decades, each with different strengths. This guide compares all three so you can read any ER diagram you encounter and choose the best notation for your team. Our Schema Designer uses a visual node-based approach inspired by Crow's Foot notation, the most common style in modern tooling.

Crow's Foot Notation (IE Notation)

Crow's Foot notation, also called Information Engineering (IE) notation, is the most widely used ER diagram style in the software industry. It uses distinctive symbols at the endpoints of relationship lines to indicate cardinality and optionality. The name comes from the three-pronged fork symbol that represents "many."

Cardinality Symbols

Each end of a relationship line has two symbols: one for the minimum cardinality (closest to the entity) and one for the maximum cardinality (at the line end). The four combinations create the following relationship types:

Reading a Crow's Foot Diagram

Read the relationship from left to right (or top to bottom): "One Customer places zero or more Orders." The verb label on the relationship line describes the action, and the symbols at each end describe the cardinality. The symbol closest to an entity describes how that entity participates.

Customer ||--o{ Order : places
Order    ||--|{ LineItem : contains
Product  ||--o{ LineItem : "is in"

This reads: each Customer places zero or more Orders, each Order contains one or more LineItems, and each Product appears in zero or more LineItems.

When to Use Crow's Foot

• Modern database design tools (most use this notation by default)
• Communication with developers and DBAs
• Mermaid ER diagrams (the erDiagram syntax uses Crow's Foot symbols)
• Any context where cardinality clarity matters most

Chen Notation

Chen notation is the original ER notation, introduced by Peter Chen in his 1976 paper. It uses distinct geometric shapes: rectangles for entities, diamonds for relationships, and ovals for attributes. Cardinality is indicated by numbers or letters (1, M, N) written near the connecting lines.

Shape Vocabulary

When to Use Chen Notation

• Academic courses and textbooks (most database courses teach Chen first)
• Conceptual modeling where you need to distinguish entities, relationships, and attributes visually
• Early-stage design before physical schema decisions are made
• When modeling complex relationships that benefit from the explicit diamond shape

UML Class Diagram Notation

UML (Unified Modeling Language) class diagrams can also represent database schemas, especially when the same diagram needs to communicate both object-oriented code structure and database design. UML uses rectangles divided into compartments (name, attributes, operations) connected by lines with multiplicity indicators.

Multiplicity Notation

Association Types

UML distinguishes between different strengths of relationship using line decorations:

• Association (plain line): a general relationship between two entities
• Aggregation (hollow diamond): a "has-a" relationship where the parts can exist independently (e.g., Department has Employees)
• Composition (filled diamond): a strong "owns" relationship where the parts cannot exist without the whole (e.g., Order owns LineItems)
• Generalization (hollow triangle): inheritance / is-a relationship (e.g., SavingsAccount is-a Account)

When to Use UML

• Teams that use UML across the stack (class diagrams for code, same notation for DB)
• Projects with ORM-heavy architectures where object model maps directly to tables
• Documentation that needs to bridge application logic and database design

Notation Comparison Summary

Choosing a Notation

For most development teams, Crow's Foot notation is the pragmatic choice. It is compact, widely understood by developers and DBAs, and supported by virtually every modern database design tool including our Schema Designer. Chen notation remains valuable in academic settings and for conceptual modeling workshops where you want to distinguish entities, relationships, and attributes at a glance. UML makes sense when your team already uses it for class diagrams and wants consistency across code and database documentation.

Regardless of notation, the underlying concepts are the same: entities, attributes, relationships, and cardinality. Once you understand these four concepts, switching between notations is straightforward.