The first relational database management system, or RDBMS, dates all the way back to 1976. Oracle Database, the most popular database platform today, originated in 1979. MySQL, the second-most popular RDBMS as of 2021, has been around since 1998.

Given that the most widely used databases at present have existed for decades, you might think that little has happened in the world of databases in recent years. After all, if we’re still using database technology that debuted back when Apple was releasing its first computer (which was also in 1976), is anything innovative going on in the database ecosystem?

The answer is a resounding yes. Although RDBMS platforms remain very important, another style of database, called NoSQL, has developed into a compelling alternative to RDBMS over the past decade. Depending on your needs, NoSQL may be a better solution than RDBMS.

Here’s an overview of the similarities and differences between RDBMS databases and NoSQL databases, along with tips on why you would choose one type of solution over the other.

RDBMS defined and examples

An RDBMS is a database that uses what’s known as a relational-data model to structure data. A relational-data model organizes data into tables, columns and rows, based on relationships between different data items (hence the term “relational-data”).

You can think of relational-data models as akin to the way data is organized within a spreadsheet, although RDBMS platforms typically handle much larger volumes of data than a spreadsheet could support. In a spreadsheet, information is structured based on relationships. You might create a column called “usernames,” for example, then fill out rows within that column by entering individual usernames. Then, you create a column next to the first one titled “login time,” and populate the rows in that column with values that are related to the usernames in the preceding column, and so on.

Relational databases work in essentially the same way, just at a larger scale. A single RDBMS table could contain tens of thousands of columns and rows if necessary — and there are often multiple tables in a single RDBMS database.

In addition to storing data in a relational way, RDBMS systems also provide a language that programmers, applications or other entities can use to look up information within their data structures. The most popular language for most RDBMS platforms in existence today is the Structured Query Language, or SQL. SQL defines a series of commands that RDBMS systems can interpret to look up, move, modify or delete information stored within their tables and columns.

As noted above, Oracle Database and MySQL are among the leading RDBMS platforms today. Other popular solutions include PostgreSQL and Microsoft SQL.

NoSQL defined and examples

A NoSQL database is one that doesn’t use a relational-data model to organize information. Instead, NoSQL databases typically use one of four alternative data storage models:

• Key-value: Each database item consists of keys, which are used to identify the item, and values, which are the data associated with the key.
• Document: Each item in the database is a “document” (which is really just a text file that is formatted in a particular way, based on file formats like JSON or YAML) that stores information. Each document stores data, and data can be retrieved by retrieving the document.
• Wide-column store: These databases store information in columns and tables, but the rules surrounding the way columns and tables may be organized are not as strict as they are with RDBMS systems. Columns may be different between different rows, for example.
• Graph: Data is organized in a way that resembles a plot graph, with each plot representing a “node” that stores information.

Although each of these approaches works in a different way, they all share the ability to structure and organize data more flexibly than an RDBMS platform could. When you are forced to put all of your data into a rigid set of tables, columns and rows, it may be hard to store data that doesn’t fit neatly into that structure. Some items may be associated with multiple other items in a way that is hard to represent using the tabular structure of an RDBMS, for instance.

Or, some items might contain much more data than others, which leads to disparity in size between tables and rows. In turn, data may be more difficult to retrieve. The database might have to work through a very long row before it can find the item you need in a shorter row, for example. That’s inefficient.

NoSQL databases mitigate these issues by avoiding the strict structures of RDBMS systems. This makes NoSQL not only more flexible, but also often more scalable, especially when you are dealing with chunks for data that vary widely in type or size.

The term NoSQL was first used in the 1990s, but it referred at the time only to the NoSQL Relational Database Management System — a platform that was actually an RDBMS. NoSQL databases as we know them today didn’t start appearing until about a decade later. CouchDB, a document-store NoSQL database that appeared in 2005, is among the oldest NoSQL platforms that are still widely used today. The wide-column database Apache Cassandra debuted in 2008. MongoDB, a document-oriented NoSQL database, and Redis, which is more or less a key-value store, both date to 2009. Redis also offers a graph-style variant, called RedisGraph.

RDBMS vs. NoSQL: Which to use?

Although NoSQL is newer than RDBMS, it would be wrong to conclude that one type of platform is universally better or more modern than the other. Both styles of database are widely deployed in application stacks of all types today, ranging from legacy applications to the most cutting-edge “cloud native” environments.

Instead, think of RDBMS and NoSQL as being suited to different use cases. In general, RDBMS platforms work best for storing and retrieving data that is predictable and consistent in format and structure. If you have an application that needs to look up names, addresses and phone numbers, for instance, RDBMS will work well. Although this data may vary somewhat in form, it’s going to take mostly the same structure across all of your entries. It’s also not likely to change form in the future; the names, addresses and phone numbers you record today are likely to be identical in format and size to those you’ll be recording five or ten years from now.

In contrast, NoSQL works best for situations where data types are less predictable or consistent. For example, imagine a data backup application that lets users upload files of any type and size that they want to back up. In this case, a NoSQL database would likely work better than an RDBMS database. It would provide the flexibility to store data of widely varying types and sizes, without having to fit it all into neatly structured tables or columns.

The advantages of NoSQL in a situation like this are not limited strictly to flexibility in the way data is organized and stored. NoSQL may also perform better at scale when dealing with data that varies in size and structure. That’s because, rather than having to parse through a long set of tables, columns and rows to read and write information, NoSQL databases can retrieve data through more efficient paths. A key-value store could look up the items needed based on their keys, without having to roam through tables and rows. A document database could pull data by finding the documents that encode it. Each document would be equally fast to access because they are not stored in hierarchical fashion.

This is not to say that RDBMS systems can’t work well at scale. They can, and they do, especially when they house consistent data types. But again, RDBMS platforms may struggle to perform well at large scale when they are working with data that is hard to fit neatly into columns, tables and rows.

Summary

Today’s developers have two key ways to organize and manage the data that powers their applications: RDBMS databases and NoSQL databases. While RDBMS organizes data using a formal structure that is comparable to a spreadsheet (but at a larger scale), NoSQL databases work in a variety of different ways, depending on which specific database you choose.

Neither solution is better for all use cases. Instead, RDBMS tends to work best for managing simpler and consistent bodies of data, while NoSQL is often a better choice for data that varies widely in type and size.