# What Is an RDBMS?

> An RDBMS (Relational Database Management System) is a DBMS built around the relational model, storing data in tables of rows and columns that relate to each other through shared key values. Every RDBMS is a DBMS, but not every DBMS is relational; PostgreSQL, MySQL, Oracle Database and SQL Server are RDBMSs, and they are almost always queried with SQL.

Canonical: https://devsunite.com/resources/core-subjects/dbms/what-is-rdbms
Last updated: 2026-11-22

Subject: DBMS · Category: RDBMS · 3 min read

An RDBMS, or Relational Database Management System, is a specific kind of DBMS built around the relational model: data organized into tables (formally called relations), where each table has rows and columns, and tables relate to each other through shared key values rather than being one giant flat structure. PostgreSQL, MySQL, Oracle Database, and SQL Server are all RDBMS software.

## Every DBMS vs. specifically an RDBMS

Every RDBMS is a DBMS, but not every DBMS is an RDBMS. A DBMS is the broad category: any software managing structured access to data. An RDBMS is the specific, most common flavor of that, one built around tables and defined relationships between them, almost always queried using SQL.

Non-relational (NoSQL) databases are also DBMS software, just built around a different data model: MongoDB stores documents, Redis stores key-value pairs, Neo4j stores graphs of nodes and edges. None of these are RDBMSs, because none of them organize data as tables related through keys the way the relational model requires.

## The defining features of an RDBMS

- **Tables (relations)** with a fixed set of typed columns and any number of rows.
- **Keys** that establish relationships: a primary key uniquely identifies each row in a table, and a foreign key in one table references a primary key in another, formally linking the two.
- **A query language**, almost universally SQL, used to define structure and manipulate data.
- **Constraints** the DBMS actively enforces: a column can be required to be unique, non-null, or restricted to a specific range or set of values.
- **ACID transactions**, guaranteeing that multi-step operations are atomic, consistent, isolated, and durable.

## A worked example

A blogging platform naturally splits into related tables rather than one giant flat table:

**`authors`**

| id | name |
|----|------|
| 1 | Meera |
| 2 | Dev |

**`posts`**

| id | title | author_id |
|----|-------|-----------|
| 101 | Learning SQL | 1 |
| 102 | Intro to Indexes | 1 |
| 103 | Graph Basics | 2 |

Here, `posts.author_id` is a foreign key referencing `authors.id`. This is the relational model in action: rather than repeating each author's full name inside every single post row (which would waste space and create a real risk of inconsistency if a name ever needed correcting), the relationship is expressed through a shared key value. A query like `SELECT posts.title FROM posts JOIN authors ON posts.author_id = authors.id WHERE authors.name = 'Meera'` uses that relationship to pull Meera's posts without any data being duplicated.

## Where this matters in real systems

The relational model has stayed dominant for decades specifically because most real-world data genuinely has these kinds of relationships, customers have orders, orders have line items, line items reference products, and RDBMSs are purpose-built to express and enforce those relationships reliably. PostgreSQL and MySQL power the backend of an enormous share of production web applications for exactly this reason: strong consistency guarantees, a mature and expressive query language, and decades of real-world performance tuning behind them.

## What interviewers actually ask about RDBMS

- **"What makes a database 'relational'?"** Data is stored in tables, and relationships between tables are expressed through keys, not by nesting or duplicating data.
- **"Is every DBMS an RDBMS?"** No. DBMS is the broad category; RDBMS specifically means the relational model. MongoDB and Redis are DBMS software but not RDBMSs.
- **"What's the role of a foreign key in an RDBMS?"** It establishes and enforces a relationship between two tables by referencing a primary key in another table.
- **"Why use multiple related tables instead of one big table?"** To avoid duplicating data (which risks inconsistency) and to let each entity type be modeled, constrained, and indexed independently.

## Key takeaways

- An RDBMS is a DBMS built around the relational model: tables related to each other through keys.
- Not every DBMS is relational, document, graph, and key-value databases are DBMS software using a different model entirely.
- Core RDBMS features are tables, primary/foreign keys, SQL, enforced constraints, and ACID transactions.
- Splitting data into related tables (instead of one flat structure) avoids duplication and keeps relationships explicit and enforceable.

## Related

- [Previous: Important DBMS Terms](https://devsunite.com/resources/core-subjects/dbms/important-terms)
- [Next: Introduction to the ER Model](https://devsunite.com/resources/core-subjects/dbms/introduction-to-er-model)
- [More in RDBMS: How to Draw an ER Diagram](https://devsunite.com/resources/core-subjects/dbms/how-to-draw-an-er-diagram)
- [More in RDBMS: Introduction to the Relational Model](https://devsunite.com/resources/core-subjects/dbms/introduction-to-relational-model)
- [More in RDBMS: Keys in the Relational Model](https://devsunite.com/resources/core-subjects/dbms/keys-in-relational-model)
- [All 174 DBMS interview questions](https://devsunite.com/resources/core-subjects/dbms)
