SQL vs. NoSQL – What Should You Use?

SQL vs. NoSQL – What Should You Use?

One of the most frequently asked questions – which database should I use?

SQL stands for Structured Query Language. It was developed in the 1970s by a group of IBM researchers. NoSQL databases were first used by Carlo Strozzi in 1998.

The most common difference between these two database systems (DB) is that SQL is relational and NoSQL is not relational.

Let’s dive deep into these two databases to better inform your decision the next time you think about a database for your project.



SQL databases have a specific schema structure.

A schema contains tables, and each table contains a specific number of columns. This means that a user cannot update the table beyond the number of columns specified in the table. This is especially useful when you need to maintain data integrity and ensure what kind of data is stored in your database.

Any table in a SQL database can be linked. That is, you can have relationships between tables. These relationships can be One-to-One, One-to-Many, or, Many-to-Many. The type of relationship you implement depends on what you need.

Consider, for example, the hypothetical situation. We have a company with users, and users can place orders for products. Then we might determine that users can create several orders, but only one user can make each order. This would be one-to-many relationships (one user to many orders). Therefore, the table structure for both tables looks similar to the one below.

In our database, we might have a user table structured as follows:

id          |          name       |           email
1                    Alan              alan@company.com

We could also have an order table

id                   |             user_id             |             order_number
1                                      1                               20000001

The Order Table is easy to assign each purchase order in the order table to the user to whom it belongs. In the case of a one-to-one relationship, we could also have this on them if we decide to identify the user by their corresponding order number.user_idorder_idusers_table

In many-to-many situations, an additional table called a pivot table is usually involved. This allows multiple records to be mapped to each other. The pivot table contains both IDs as foreign keys.

id               |                  order_id              |           user_id
1                                     1                                 1

Based on this structure provided by SQL, you can easily write joins between tables that provide data from different tables that are interconnected in a query.


NoSQL Databases have been created more flexibly than SQL DBs and also contain larger amounts of data.

There are no predefined schemas or tables in NoSQL DBs. There are collections and documents in every collection. This allows you to store data in different forms. You can select several different documents with different fields in a collection. It is also possible to establish relationships between collections manually. However, they are not suitable for such a purpose. Instead, you can store everything you need for a single query in the same collection.

If you are a SQL person, you can think of collections as tables and documents as rows with tables. However, there are no restrictions on the columns of data that you can add to the table.

Back to our previously defined hypothetical instance of a company with users and orders.

A user collection can be defined as:

{id: 1, name: 'Alan', email: 'alan@company.com'}

And the order collection could be defined as:

{id: 1, order_number: 2000001, user_id:1}

In this case, however, we want to avoid having to connect both collections manually. We can store entries in the collection that are read the most. We have decided (for this example) that this will be the order collection.

{id:1, order_number:200001, user{id:1, name: 'Alan', email:'alan@company.com'}}

In this case, we no longer need to read from the user collection and only from the job collection, which now contains all the data we need.

One important thing to keep in mind here: If you’re creating an app that reads a lot more than writes, a NoSQL option is probably better for you. Because you can store all your data in the same collection and conveniently read it from that source to get all the data you need.

However, for an app that requires many writes (approximately 10,000 writes per second) on this scale, it is not a good idea to use NoSQL, where you must write the same data to multiple locations. In this situation, an SQL option is probably better if there are relationships to all tables and the same data does not need to be repeatedly written to multiple locations. Updating data in one location can be available by exiting for other tables’ relationships. Of course, this does not mean that each of these databases cannot handle scaling.



SQL DBs cannot be scaled horizontally, only vertically.

Scale-out means splitting data from one database into multiple databases to make loading easier. However, SQL data cannot be split into separate DBs due to its strict nature. The correct scaling of a SQL database is to increase the CPU, memory, and storage space of the existing DB server. This means that the vertical database is scaled vertically.

database vertical vs. horizontal scaling
database vertical vs. horizontal scaling


NoSQL DBs can be scaled horizontally and vertically. This is due to the flexibility of data storage. This allows the data to be split into multiple databases, as is the case with horizontal scaling. If necessary, it can also be scaled vertically.

One important thing to keep in mind here: Scaling can effectively scale both SQL and NoSQL databases. For SQL DBs, however, vertical scaling may be a restriction. A single DB server is limited in its computing power.

It is also important to note that for most applications you build, you may not achieve the maximum computing power of your server. However, it is helpful to take this into account. However, for large business applications that implement SQL, a popular option to work around this limitation is sharpening.

What are Shards?

Sharding can be achieved by horizontally partitioning a database. This is not to be confused with vertical and horizontal scaling. Horizontal partitioning refers to the process of storing table rows in multiple database nodes. Vertical partitioning, on the other hand, requires columns of a table to be stored on different nodes. This can effectively scale the database and improve performance.

Database samples


  • MySQL – A very popular open-source database. However, the database of choice for many PHP developers can easily be used with Node.js, C, C ++, Java, Perl, Ruby, and Python.
  • MSSQL – Microsoft SQL provides a lot of stability because its development comes directly from Microsoft, which also provides disaster recovery assistance.
  • MariaDB – This was built by the manufacturers of MySQL on MySQL to keep MariaDB as a free version forever.
  • PostgresSQL – A very popular open-source database. Proud of the world’s most advanced open source database
  • Oracle – This is typically tailored to Oracle’s enterprise solutions, with some limitations in the free version.


  • MongoDB – Probably the best-known NoSQL database common among application developers working with MERN stack (MongoDB, Express, React, Node) or MEAN stack (MongoDB, Express, Angular, Node).
  • Firebase – launched in 2011 and acquired by Google in 2014, it is widely used by developers of web and mobile applications.
  • Apache Couch DB – A document-based NoSQL database that stores data as JSON.
  • Redis: This is NoSQL DB, probably best known for its use to store data with an optional lifetime. It is also known for its speed.


You can create any type of application with a SQL or NoSQL database. It depends on your needs. If you are considering a database in which you are performing more reads and writes, NoSQL may be a good option. However, if you are considering creating an app with more writes than reads, SQL may be the better solution. In terms of scalability, you may use both DBs when your app reaches a very large scope.


Write a Reply or Comment

Your email address will not be published. Required fields are marked *

This site is protected by reCAPTCHA and the Google Privacy Policy and Terms of Service apply.