---
description: What is the ER Model? The ER or (Entity Relational Model) is a high-level conceptual data model diagram. Entity-Relation model is based on the notion of real-world entities and the relationship betwee
title: Entity Relationship (ER) Diagram Model with DBMS Example
image: https://www.guru99.com/images/er-diagram-tutorial-dbms-1.png
---

 

[Skip to content](#main) 

**⚡ Smart Summary**

**The Entity Relationship (ER) Diagram Model with DBMS Example** illustrates a structured method to visually represent data and its interconnections within relational databases. Proposed by Peter Chen, it provides a conceptual modeling foundation to define entities, attributes, relationships, and their cardinalities precisely.

* **🔍 Core Concept:** ER Diagrams define database structure through three core components—Entities, Attributes, and Relationships—ensuring clear mapping between data objects and their interactions.
* **🧱 Structural Symbols:** Rectangles denote entities, ellipses represent attributes, and diamonds illustrate relationships; connecting lines indicate logical links, with underlined attributes marking primary keys.
* **⚙️ Entity Classification:** Entities are grouped into sets, each identified by unique keys or attributes. Weak entities lack independent keys and rely on strong entities for identification, using double rectangles and dashed underlines.
* **🔗 Relationship Definition:** Relationships express associations between entities (e.g., “Student enrolls in Course”) and are categorized by cardinality—one-to-one, one-to-many, many-to-one, or many-to-many.
* **🧩 Attribute Types:** Attributes can be simple, composite, derived, or multivalued, defining distinct data properties such as names, dates, and computed fields.
* **🧭 ERD Creation Steps:** Identify entities, establish relationships, determine cardinalities, assign attributes, and define primary keys before constructing the complete diagram.
* **📈 Optimization Practice:** Remove redundancies, label all components, and maintain unique entity occurrences for clarity, ensuring the diagram supports all necessary data storage requirements.

[ Read More ](javascript:void%280%29;) 

![Entity Relationship Diagram](https://www.guru99.com/images/er-diagram-tutorial-dbms-2.png)

## What is an ER Diagram?

The Entity Relationship (ER) Diagram is a powerful visual tool for designing relational database structures. First proposed by Peter Chen in 1976, it provides a conceptual modeling foundation that defines entities, attributes, relationships, and their cardinalities with precision. This tutorial covers everything from basic concepts to advanced techniques, helping you master database schema design.

ER Diagrams contain different symbols that use rectangles to represent entities, ovals to define attributes, and diamond shapes to represent relationships.

At first glance, an ER Diagram looks very similar to a flowchart. However, an ER Diagram includes many specialized symbols, and its meanings make this model unique. The purpose of an ER Diagram is to represent the entity framework infrastructure.

[](https://www.guru99.com/images/1/100518%5F0621%5FERDiagramTu1.png)

Entity Relationship Diagram Example

## History of ER Models

Peter Chen proposed the ER Diagram in 1976 in his seminal paper “The Entity-Relationship Model: Toward a Unified View of Data.” His goal was to create a uniform convention that could be used for both relational databases and networks. Chen envisioned the ER Model as a conceptual modeling approach that would bridge the gap between real-world requirements and technical database implementation.

Since then, the ER Model has evolved with various notation systems, including Chen Notation (the original), Crow’s Foot Notation (popular in modern tools), and UML-based approaches. Despite these variations, the core concepts remain consistent across all implementations.

### Why Use ER Diagrams?

ER Diagrams provide numerous benefits for database design and development:

* **Visual Communication:** They provide a clear visual representation that both technical and non-technical stakeholders can understand.
* **Blueprint for Development:** They show exactly how tables should connect and what fields each table will contain.
* **Translation Ready:** ER Diagrams can be directly translated into relational tables, allowing you to build databases quickly.
* **Error Prevention:** They help identify design flaws and redundancies before implementation, saving time and resources.
* **Documentation:** They serve as lasting documentation that helps new team members understand the system architecture.
* **System Analysis:** They help identify all entities that exist in a system and the relationships between them.

## ER Diagram Components

Every ER Diagram is built from three core components: Entities, Attributes, and Relationships. Understanding each component and how they interact is essential for creating effective database designs.

**ER Diagram Examples**

For example, in a University database, we might have entities for Students, Courses, and Lecturers. A student entity can have attributes like Rollno, Name, and DeptID. They might have relationships with Courses and Lecturers.

[](https://www.guru99.com/images/1/100518%5F0621%5FERDiagramTu2.png) 

Components of the ER Diagram

### RELATED ARTICLES

* [Relational Data Model in DBMS | Database Concepts & Example ](https://www.guru99.com/relational-data-model-dbms.html "Relational Data Model in DBMS | Database Concepts & Example")
* [Top 50 Database Interview Questions and Answers (2026) ](https://www.guru99.com/database-interview-questions.html "Top 50 Database Interview Questions and Answers (2026)")
* [DBMS Joins: Inner, THETA, Outer, Equi Types of Join Operations ](https://www.guru99.com/joins-sql-left-right.html "DBMS Joins: Inner, THETA, Outer, Equi Types of Join Operations")
* [Indexing in DBMS: What is, Types of Indexes with EXAMPLES ](https://www.guru99.com/indexing-in-database.html "Indexing in DBMS: What is, Types of Indexes with EXAMPLES")

### Entities

An entity represents any real-world object—living or non-living—that can be clearly identified and about which data can be stored. It may be a physical thing, a fact about the enterprise, or an event that happens in the real world. Entities can include people, places, objects, events, or concepts.

Examples of entities by category:

* **Person:** Employee, Student, Patient, Customer
* **Place:** Store, Building, Office, Warehouse
* **Object:** Machine, Product, Car, Book
* **Event:** Sale, Registration, Renewal, Transaction
* **Concept:** Account, Course, Department, Project

[](https://www.guru99.com/images/examples-of-entities-in-dbms.png)

### Entity Set

An entity set is a group of similar entities that share common attributes. For example, all students in a university form a “Student” entity set. Entities are represented in ER Diagrams using rectangles, with the entity name written inside.

Entities are represented by their properties, which are also called attributes. All attributes have their separate values. For example, a student entity may have a name, age, and class as attributes.

[](https://www.guru99.com/images/1/100518%5F0621%5FERDiagramTu3.png)

#### Strong Entities vs. Weak Entities

Entities are classified as either strong or weak based on their ability to exist independently. Understanding this distinction is crucial for proper database design.

A strong entity has its own primary key and can exist independently. For example, a “Student” entity can be uniquely identified by Student\_ID without depending on any other entity.

A weak entity lacks a primary key of its own and depends on a strong entity (called the owner entity) for its identification. It uses a partial key (discriminator) combined with the owner’s primary key to achieve uniqueness. For example, in a banking system, a “Transaction” entity depends on an “Account” entity—the transaction number alone isn’t unique across the entire database, but combined with the account number, it becomes unique.

[](https://www.guru99.com/images/1/100518%5F0621%5FERDiagramTu5.png)

| Strong Entity                              | Weak Entity                                              |
| ------------------------------------------ | -------------------------------------------------------- |
| Has its own primary key                    | Does not have a primary key; uses partial key            |
| Represented by a single rectangle          | Represented by a double rectangle                        |
| Primary key is underlined with solid line  | Partial key is underlined with dashed line               |
| Can exist independently                    | Depends on owner entity for existence                    |
| Connected with single diamond relationship | Connected with double diamond (identifying relationship) |
| Example: Student, Employee, Product        | Example: Transaction, Dependent, Order\_Item             |

## Relationship

A relationship represents an association between two or more entities. Relationships are typically identified using verbs or verb phrases that describe how entities interact with each other. In ER Diagrams, relationships are represented using diamond shapes. Example: Tom works in the Chemistry department.

[](https://www.guru99.com/images/1/100518%5F0621%5FERDiagramTu4.png)

Entities take part in relationships. We can often identify relationships with verbs or verb phrases.

**Examples:**

* You are attending this lecture
* I am giving the lecture
* A student attends a lecture
* A lecturer is giving a lecture

### Attributes

An attribute is a property or characteristic that describes an entity or relationship. Attributes provide the detailed information that makes each entity instance unique and meaningful. In ER Diagrams, attributes are represented using ovals (ellipses) connected to their parent entity by a line.

[](https://www.guru99.com/images/1/100518%5F0621%5FERDiagramTu6.png)

For example, a Student entity might have attributes such as Student\_ID, Name, Date\_of\_Birth, Email, and Phone\_Number.

#### Types of Attributes

| Attribute Type  | Description                                                    | Example                                                      |
| --------------- | -------------------------------------------------------------- | ------------------------------------------------------------ |
| Simple (Atomic) | Cannot be divided further into smaller components              | Phone Number, SSN, Email                                     |
| Composite       | Can be broken down into smaller sub-attributes                 | Full Name (First, Middle, Last), Address (Street, City, ZIP) |
| Derived         | Value is calculated from other attributes; not stored directly | Age (derived from Date of Birth), Total Price                |
| Multivalued     | Can hold multiple values for a single entity                   | Phone Numbers, Email Addresses, Skills                       |
| Key Attribute   | Uniquely identifies each entity instance (Primary Key)         | Student\_ID, Employee\_ID, ISBN                              |

**Key Tip:** In ER Diagrams, key attributes are shown with their names underlined. Derived attributes are shown in dashed ovals, and multivalued attributes are shown in double ovals.

## Cardinality (Relationship Types)

Cardinality defines the numerical constraints of a relationship—specifically, how many instances of one entity can be associated with instances of another entity. Understanding cardinality is essential for designing efficient database structures.

[](https://www.guru99.com/images/1/100518%5F0621%5FERDiagramTu7.png)

**1\. One-to-One (1:1)**

One entity from set A can be associated with at most one entity from set B, and vice versa.

Example: One student is assigned exactly one student ID, and each student ID belongs to exactly one student.

[](https://www.guru99.com/images/1/100518%5F0621%5FERDiagramTu8.png)

**2\. One-to-Many (1:N)**

One entity from set A can be associated with multiple entities from set B, but each entity in B is associated with only one entity in A.

Example: One class consists of multiple students.

[](https://www.guru99.com/images/1/100518%5F0621%5FERDiagramTu9.png)

**3\. Many-to-One (N:1)**

Multiple entities from set A can be associated with one entity from set B.

For example, many students belong to the same class.

[](https://www.guru99.com/images/1/100518%5F0621%5FERDiagramTu10.png)

**4\. Many-to-Many (M:N)**

Multiple entities from set A can be associated with multiple entities from set B, and vice versa.

For example, Students as a group are associated with multiple faculty members, and faculty members can be associated with multiple students.

[](https://www.guru99.com/images/1/100518%5F0621%5FERDiagramTu11.png)

## ER Diagram Symbols and Notations

ER Diagrams use standardized symbols to represent different components. While there are several notation systems, the two most widely used are Chen Notation and Crow’s Foot Notation.

### Chen Notation

Chen Notation, developed by Peter Chen in 1976, uses geometric shapes to represent different elements:

| Symbol           | Name                     | Represents                                           |
| ---------------- | ------------------------ | ---------------------------------------------------- |
| Rectangle        | Entity                   | Strong entity (e.g., Student, Product)               |
| Double Rectangle | Weak Entity              | Entity dependent on another (e.g., Transaction)      |
| Ellipse/Oval     | Attribute                | Property of an entity (e.g., Name, ID)               |
| Double Ellipse   | Multivalued Attribute    | Attribute with multiple values (e.g., Phone Numbers) |
| Dashed Ellipse   | Derived Attribute        | Calculated value (e.g., Age from DOB)                |
| Diamond          | Relationship             | Association between entities (e.g., Enrolls)         |
| Double Diamond   | Identifying Relationship | Relationship with weak entity                        |
| Line             | Link                     | Connects components together                         |
| Underlined Text  | Primary Key              | Unique identifier for entity                         |

**Crow’s Foot Notation**

Crow’s Foot Notation (also called IE Notation) is more commonly used in modern database design tools. It uses different line endings to represent cardinality and is particularly effective for showing the “many” side of relationships.

| Symbol Description           | Meaning                      |
| ---------------------------- | ---------------------------- |
| Single vertical line (\|)    | Mandatory One (exactly one)  |
| Circle with line (O\|)       | Optional One (zero or one)   |
| Crow’s foot with line (>\|)  | Mandatory Many (one or more) |
| Crow’s foot with circle (>O) | Optional Many (zero or more) |

**Chen Notation vs. Crow’s Foot: When to Use Each**

| Aspect            | Chen Notation                     | Crow’s Foot Notation                    |
| ----------------- | --------------------------------- | --------------------------------------- |
| Best For          | Conceptual modeling, academic use | Physical/logical modeling, industry use |
| Attribute Display | Shows all attributes visually     | Lists attributes inside entity box      |
| Cardinality       | Uses numbers (1, N, M)            | Uses visual symbols                     |
| Complexity        | Can become cluttered              | More compact and cleaner                |
| Tool Support      | Limited modern tool support       | Widely supported in tools               |

## How to Create an Entity Relationship Diagram (ERD)

Now in this ER Diagram (ERD) Tutorial, we will learn how to create an ER Diagram. The following are the steps to create an ER Diagram:

[](https://www.guru99.com/images/1/100518%5F0621%5FERDiagramTu13.png) 

Steps to Create an ER Diagram

Let’s study them with an Entity Relationship Diagram Example:

In a university, a Student enrolls in Courses. A student must be assigned to at least one course. A single Professor teaches each course. To maintain instruction quality, a Professor can deliver only one course.

### Step 1) Entity Identification

We have three entities:

* Student
* Course
* Professor

[](https://www.guru99.com/images/1/100518%5F0621%5FERDiagramTu14.png)

### Step 2) Relationship Identification

We have the following two relationships:

* The student is **assigned** a course
* The professor **delivers** a course

[](https://www.guru99.com/images/1/100518%5F0621%5FERDiagramTu15.png)

### Step 3) Cardinality Identification

From the problem statement, we know that:

* A student can be assigned **multiple** courses
* A Professor can deliver only **one** course

[](https://www.guru99.com/images/1/100518%5F0621%5FERDiagramTu16.png)

### Step 4) Identify Attributes

You need to study the files, forms, reports, and data currently maintained by the organization to identify attributes. You can also conduct interviews with various stakeholders to identify entities. Initially, it’s important to identify the attributes without mapping them to a particular entity.

Once you have a list of Attributes, you need to map them to the identified entities. Ensure an attribute is to be paired with exactly one entity. If you think an attribute should belong to more than one entity, use a modifier to make it unique.

Once the mapping is done, identify the primary Keys. If a unique key is not readily available, create one.

| Entity    | Primary Key  | Attribute     |
| --------- | ------------ | ------------- |
| Student   | Student\_ID  | StudentName   |
| Professor | Employee\_ID | ProfessorName |
| Course    | Course\_ID   | CourseName    |

[](https://www.guru99.com/images/1/100518%5F0621%5FERDiagramTu17.png)

For Course Entity, attributes could be Duration, Credits, Assignments, etc. For the sake of ease, we have considered just one attribute.

### Step 5) Create the ERD

A more modern representation of an Entity Relationship Diagram Example:

[](https://www.guru99.com/images/1/100518%5F0621%5FERDiagramTu18.png)

## Best Practices for Effective ER Diagrams

Follow these guidelines to create clear, maintainable, and effective ER Diagrams:

* **Eliminate Redundancy:** Remove duplicate entities, attributes, or relationships.
* **Use Clear Naming Conventions:** Use consistent, descriptive names. Avoid abbreviations.
* **Validate Against Requirements:** Ensure diagram supports all data storage needs.
* **Keep It Simple:** Create multiple diagrams at different levels rather than one cluttered diagram.
* **Use Color Sparingly:** Use colors consistently to highlight categories.
* **Document Assumptions:** Include notes explaining assumptions about business rules.
* **Review with Stakeholders:** Have business users and technical team review the diagram.
* **Version Control:** Maintain versions as the design evolves.

## ER Diagrams vs. UML Class Diagrams

While both ER Diagrams and UML Class Diagrams are used for data modeling, they serve different purposes and contexts. Understanding when to use each is important for effective system design.

| Aspect             | ER Diagram                             | UML Class Diagram               |
| ------------------ | -------------------------------------- | ------------------------------- |
| Primary Purpose    | Database design                        | Software/object design          |
| Focus              | Data and relationships                 | Objects, methods, and behaviors |
| Methods/Operations | Not supported                          | Fully supported                 |
| Inheritance        | Limited (in EER only)                  | Full support                    |
| Industry Use       | Database administrators, data analysts | Software developers, architects |

## FAQs

📦 What is the function of an ER Diagram?

An ER Diagram visually represents the structure of a database by defining entities, their attributes, and relationships. It helps designers, developers, and stakeholders ensure consistency, integrity, and efficiency in data modeling before implementation begins.

🔧 What are the two main types of ER Diagrams?

The two main types are Conceptual ER Diagrams (which outline high-level relationships and entities without implementation details) and Physical ER Diagrams (which detail actual database structures, data types, keys, and constraints for implementation).

🎯 How do you create an ER Diagram?

To create an ER Diagram: (1) Identify key entities from your requirements, (2) Determine relationships between entities, (3) Assign cardinalities based on business rules, (4) Define attributes for each entity, (5) Identify primary keys, and (6) Draw the diagram using appropriate notation.

🤖 Which notation should I use for ER Diagrams?

The choice depends on your context. Chen Notation is best for conceptual design and academic settings, while Crow’s Foot Notation is preferred for logical/physical design in industry settings. Most modern database tools support Crow’s Foot notation.

📋 What is the difference between a strong and weak entity?

A strong entity has its own primary key and can exist independently. A weak entity lacks a primary key and depends on a strong entity for its identification, using a combination of the owner’s primary key and its own partial key (discriminator).

⚙️ How do ER Diagrams support automation in cloud-based DBMS?

In cloud DBMS platforms, ER Diagrams guide automated provisioning, scaling, and query orchestration. They enable AI-driven tools to align data structures with workload predictions and real-time user demand, improving system efficiency.

✅ Can generative AI fully automate database design using ER modeling?

While generative AI can propose initial ER models from business requirements or existing datasets, human oversight remains critical to validate relationships, enforce constraints, ensure logical coherence, and verify alignment with actual business rules in production systems.

🔗 How do I handle many-to-many relationships in an actual database?

Many-to-many relationships cannot be directly implemented in relational databases. You must create an associative entity (junction table) that breaks the M:N relationship into two 1:N relationships. This junction table contains foreign keys referencing both original entities.

#### Summarize this post with:

ChatGPT Perplexity Grok Google AI 

**Stay Updated on AI** **Get Weekly AI Skills, Trends, Actionable Advice.** 

##### Sign up for the newsletter

Subscribe for Free 

You have successfully subscribed.  
Please check your inbox. 

![AI-Newsletter]() Chosen by over **350,000+** professionals 

[Scroll to top ](#wrapper)Scroll to top 

× 

Toggle Menu Close 

Search for: 

Search

```json
{"@context":"https://schema.org","@graph":[{"@type":"Organization","@id":"https://www.guru99.com/#organization","name":"Guru99","sameAs":["https://www.facebook.com/Guru99Official","https://twitter.com/guru99com"],"logo":{"@type":"ImageObject","@id":"https://www.guru99.com/#logo","url":"https://www.guru99.com/images/guru99-logo-v1-150x59.png","contentUrl":"https://www.guru99.com/images/guru99-logo-v1-150x59.png","caption":"Guru99","inLanguage":"en-US"}},{"@type":"WebSite","@id":"https://www.guru99.com/#website","url":"https://www.guru99.com","name":"Guru99","publisher":{"@id":"https://www.guru99.com/#organization"},"inLanguage":"en-US"},{"@type":"ImageObject","@id":"https://www.guru99.com/images/er-diagram-tutorial-dbms-1.png","url":"https://www.guru99.com/images/er-diagram-tutorial-dbms-1.png","width":"1203","height":"742","inLanguage":"en-US"},{"@type":"BreadcrumbList","@id":"https://www.guru99.com/er-diagram-tutorial-dbms.html#breadcrumb","itemListElement":[{"@type":"ListItem","position":"1","item":{"@id":"https://www.guru99.com","name":"Home"}},{"@type":"ListItem","position":"2","item":{"@id":"https://www.guru99.com/dbms","name":"DBMS"}},{"@type":"ListItem","position":"3","item":{"@id":"https://www.guru99.com/er-diagram-tutorial-dbms.html","name":"Entity Relationship (ER) Diagram Model with DBMS Example"}}]},{"@type":"WebPage","@id":"https://www.guru99.com/er-diagram-tutorial-dbms.html#webpage","url":"https://www.guru99.com/er-diagram-tutorial-dbms.html","name":"Entity Relationship (ER) Diagram Model with DBMS Example","dateModified":"2026-01-24T19:53:37+05:30","isPartOf":{"@id":"https://www.guru99.com/#website"},"primaryImageOfPage":{"@id":"https://www.guru99.com/images/er-diagram-tutorial-dbms-1.png"},"inLanguage":"en-US","breadcrumb":{"@id":"https://www.guru99.com/er-diagram-tutorial-dbms.html#breadcrumb"}},{"@type":"Person","@id":"https://www.guru99.com/author/fiona","name":"Fiona Brown","description":"I'm Fiona brown, a Full Stack Developer with over a decade of experience, sharing practical guides on robust and scalable application development.","url":"https://www.guru99.com/author/fiona","image":{"@type":"ImageObject","@id":"https://www.guru99.com/images/fiona-brown-author.png","url":"https://www.guru99.com/images/fiona-brown-author.png","caption":"Fiona Brown","inLanguage":"en-US"},"worksFor":{"@id":"https://www.guru99.com/#organization"}},{"@type":"Article","headline":"Entity Relationship (ER) Diagram Model with DBMS Example","description":"What is the ER Model? The ER or (Entity Relational Model) is a high-level conceptual data model diagram. Entity-Relation model is based on the notion of real-world entities and the relationship betwee","author":{"@id":"https://www.guru99.com/author/fiona","name":"Fiona Brown"},"copyrightYear":"2026","name":"Entity Relationship (ER) Diagram Model with DBMS Example","articleSection":"DBMS","subjectOf":[{"@type":"HowTo","name":"How to Create an Entity Relationship Diagram (ERD)","description":"Now in this ERD Diagram Tutorial, we will learn how to create an ER Diagram. Following are the steps to create an ER Diagram:","step":[{"@type":"HowToStep","name":"Entity Identification","text":"We have three entities <ul><li>Student</li><li>Course</li><li>Professor</li>","image":"https://www.guru99.com/images/1/100518_0621_ERDiagramTu14.png","url":"https://www.guru99.com/tic-tac-toe-python.html#step1"},{"@type":"HowToStep","name":"Relationship Identification","text":"We have the following two relationships<ul><li>The student is assigned a course</li><li>Professor delivers a course</li></ul>","image":"https://www.guru99.com/images/1/100518_0621_ERDiagramTu15.png","url":"https://www.guru99.com/tic-tac-toe-python.html#step2"},{"@type":"HowToStep","name":"Cardinality Identification","text":"For them problem statement we know that,<ul><li>A student can be assigned multiple courses</li><li>A Professor can deliver only one course</li></ul>","image":"https://www.guru99.com/images/1/100518_0621_ERDiagramTu16.png","url":"https://www.guru99.com/tic-tac-toe-python.html#step3"},{"@type":"HowToStep","name":"Identify Attributes","text":"You need to study the files, forms, reports, data currently maintained by the organization to identify attributes. You can also conduct interviews with various stakeholders to identify entities. Initially, it\u2019s important to identify the attributes without mapping them to a particular entity.","image":"https://www.guru99.com/images/1/100518_0621_ERDiagramTu17.png","url":"https://www.guru99.com/tic-tac-toe-python.html#step4"},{"@type":"HowToStep","name":"Create the ERD Diagram","text":"A more modern representation of Entity Relationship Diagram Example","image":"https://www.guru99.com/images/1/100518_0621_ERDiagramTu18.png","url":"https://www.guru99.com/tic-tac-toe-python.html#step5"}]}],"@id":"https://www.guru99.com/er-diagram-tutorial-dbms.html#schema-513946","isPartOf":{"@id":"https://www.guru99.com/er-diagram-tutorial-dbms.html#webpage"},"publisher":{"@id":"https://www.guru99.com/#organization"},"image":{"@id":"https://www.guru99.com/images/er-diagram-tutorial-dbms-1.png"},"inLanguage":"en-US","mainEntityOfPage":{"@id":"https://www.guru99.com/er-diagram-tutorial-dbms.html#webpage"}}]}
```
