# Important DBMS Terms

> Important DBMS terms are the core vocabulary used across database topics. A schema is the database's structure while an instance is its actual data at a moment in time; a data model is a way of organizing data; metadata is data about data; and entity, attribute, tuple and domain describe what is stored, its properties, a row and allowed values.

Canonical: https://devsunite.com/resources/core-subjects/dbms/important-terms
Last updated: 2026-11-22

Subject: DBMS · Category: Introduction · 4 min read

Before going deeper into DBMS topics, it helps to have a shared, precise vocabulary. These terms come up constantly and get used loosely in casual conversation, but they have specific, distinct meanings.

## Schema vs. instance

A **schema** is the overall design or structure of a database: the tables, their columns, data types, and relationships. It's defined once and changes relatively rarely.

An **instance** is the actual data in the database at a specific moment in time. The schema is the blueprint; the instance is the current state of the house built from that blueprint. A database's schema stays the same while its instance changes constantly as rows are inserted, updated, and deleted.

## Data model

A **data model** is a conceptual way of organizing and representing data. The relational model (tables with rows and columns, related by keys) is the most common, but others exist: the document model (used by databases like MongoDB), the graph model (nodes and edges, used by databases like Neo4j), and the key-value model (simple key-to-value lookups, used by systems like Redis).

## Metadata

**Metadata** is data about data. A table's column names, data types, and constraints are metadata, they describe the actual data (the rows) without being the data itself. Most DBMS software stores this metadata in a special internal set of tables often called a system catalog or data dictionary.

## Entity, attribute, and tuple

An **entity** is a real-world object or concept the database represents, like a customer or a product. An **attribute** is a property of that entity, like a customer's name or email. A **tuple** is the formal relational-model term for a single row in a table, one specific instance of an entity with actual values filled in for each attribute.

## Domain

A **domain** is the set of allowed values for an attribute. The domain of an "age" attribute might be defined as non-negative integers; the domain of a "status" attribute might be restricted to exactly the values `'active'`, `'inactive'`, or `'pending'`.

## A worked example

Take a `students` table:

| id | name | age | status |
|----|------|-----|--------|
| 1 | Asha | 21 | active |
| 2 | Ravi | 22 | inactive |

- The **schema** is the definition: `students(id INT, name VARCHAR, age INT, status VARCHAR)`.
- The **instance** is the two actual rows shown above, right now, at this moment.
- `students` represents the **entity** "student."
- `name`, `age`, and `status` are **attributes** of that entity.
- Each full row, like `(1, 'Asha', 21, 'active')`, is a **tuple**.
- The **domain** of `status` is restricted to a small fixed set of values, `active`, `inactive`, `pending`, not any arbitrary text.
- The table's own definition (its column names and types) is stored as **metadata** in the DBMS's internal catalog.

## Where this matters in real systems

This vocabulary isn't just academic. When a DBA says "the schema changed" versus "the data changed," they mean genuinely different things with different implications, a schema change often requires careful migration planning and can briefly lock a table, while data changes (inserts, updates) happen constantly without any special coordination. Being precise with these terms is also what lets engineers communicate clearly during incident response, "is this a schema problem or a data problem" is often the very first triage question.

## What interviewers actually ask about DBMS terminology

- **"What's the difference between a schema and an instance?"** Schema is the fixed structure/design; instance is the actual data at a given point in time, which changes constantly.
- **"What is metadata, and where is it stored?"** Data about data, like column names and types, usually stored in the DBMS's own internal system catalog.
- **"What's a tuple, in relational database terms?"** A single row in a table, representing one instance of an entity.
- **"Name some data models other than the relational model."** Document (MongoDB), graph (Neo4j), key-value (Redis) are all valid, showing awareness that "database" doesn't only mean "relational table."

## Key takeaways

- A schema is the database's structure; an instance is its actual data at a moment in time.
- A data model is the conceptual approach to organizing data, relational, document, graph, and key-value are the major ones.
- Metadata is data about data, like column names and types, stored in the DBMS's system catalog.
- Entity, attribute, and tuple map to table, column, and row in relational-model terms.
- A domain defines the set of legal values an attribute can hold.

## Related

- [Previous: Data Abstraction (Physical, Logical, View Levels)](https://devsunite.com/resources/core-subjects/dbms/data-abstraction)
- [Next: What Is an RDBMS?](https://devsunite.com/resources/core-subjects/dbms/what-is-rdbms)
- [More in Introduction: What Is a DBMS?](https://devsunite.com/resources/core-subjects/dbms/what-is-dbms)
- [More in Introduction: DBA (Database Administrator) and Functions](https://devsunite.com/resources/core-subjects/dbms/dba-and-functions)
- [More in Introduction: DBMS Architecture (1-Tier, 2-Tier, 3-Tier)](https://devsunite.com/resources/core-subjects/dbms/dbms-architecture)
- [More in Introduction: Database Languages (DDL, DML, DCL, TCL)](https://devsunite.com/resources/core-subjects/dbms/database-languages)
- [All 174 DBMS interview questions](https://devsunite.com/resources/core-subjects/dbms)
