MongoDB

What is MongoDB?

MongoDB is an open-source database system that stores data in a fundamentally different way than traditional databases. Where classic databases work with tables and rows, MongoDB uses so-called documents: flexible data blocks in a JSON-like format called BSON. This makes it easier to store complex and changing data structures.

MongoDB falls under the category of NoSQL databases. That means it does not require a fixed table structure. You can store data without first defining a strict schema. This gives developers a lot of freedom, especially in projects where the data structure is still evolving.

The database was developed by the American company MongoDB, Inc. and first released in 2009. Today it is one of the most widely used databases in the world, adopted by startups and large enterprises alike.

How is data organized?

In MongoDB, data is stored in documents, which are grouped into collections. A collection is comparable to a table in a relational database, but without fixed columns. Each document can have its own structure, which makes the system particularly flexible.

An example of a MongoDB document looks like this:

{
  "name": "John Smith",
  "age": 34,
  "email": "john@example.com",
  "address": {
    "city": "New York",
    "zipcode": "10001"
  }
}

As you can see, documents can contain nested data. That is a major advantage over traditional databases, where you would need multiple tables and joins to achieve the same result.

MongoDB environments

MongoDB is available in several environments. You can install it locally on your own server (self-hosted), or use MongoDB Atlas: the fully managed cloud platform from MongoDB, Inc. Atlas runs on AWS, Google Cloud, and Azure, and is for many teams the easiest way to get started quickly.

How does MongoDB work?

MongoDB stores data as BSON documents. BSON stands for Binary JSON and is a binary version of the well-known JSON format. It supports more data types than standard JSON, such as dates and binary data. For the user, it simply looks like JSON.

When you save a document, you decide which fields it contains. There is no mandatory structure. Two documents in the same collection can look completely different. This is called a schemaless approach, although you can optionally set validation rules.

MongoDB works with a driver on the application side. That driver translates the commands from your code into MongoDB queries. Official drivers are available for Python, JavaScript, Java, C#, Go, and many other languages.

Documents and collections

A document is the smallest unit in MongoDB. It is comparable to a row in a relational database, but richer in structure. A document can contain text, numbers, arrays, and nested objects, all in one block.

Collections are groups of documents. They are similar to tables, but without fixed columns. You create a collection simply by inserting a document into it. MongoDB handles the rest automatically.

Documents in the same collection automatically receive a unique field: _id. This is the primary key. If you do not provide one yourself, MongoDB generates it automatically.

MongoDB vs. relational databases (RDBMS)

The biggest difference from a relational database like MySQL or PostgreSQL lies in the structure. A relational database works with tables, rows, and columns. Relationships between data are defined through foreign keys and tables are combined using joins.

MongoDB works differently. Instead of splitting data across multiple tables, you store it together in a single document. That makes reading faster, but requires a different way of thinking when designing your database.

The table below gives an overview of the key differences:

Neither is universally better. A relational database is strong when it comes to complex relationships and transactions. MongoDB excels with large volumes of data, rapid development, and flexible data structures.

Key features

MongoDB offers an extensive set of features that make it suitable for a wide range of applications. Below is an overview of the most relevant ones.

Ad-hoc queries

MongoDB supports ad-hoc queries. That means you can search, filter, and sort on any field in a document, without having to define the query in advance. This gives developers a lot of freedom when building and testing an application.

You can search for exact values, but also for ranges, regular expressions, or nested fields. MongoDB's query language, MQL (MongoDB Query Language), is intuitive and well documented.

Indexing

Without indexes, MongoDB scans every document in a collection for every query. That works fine with small datasets, but slows down as data grows. With an index, you store a sorted reference to a specific field, allowing MongoDB to find the right document much faster.

MongoDB supports several types of indexes. In addition to single-field indexes, there are compound indexes, text indexes for word-based search, and geo indexes for location-based queries.

Replication

MongoDB provides built-in replication through a replica set. A replica set consists of multiple servers, each holding a copy of the same data. One server acts as the primary node and handles all write operations. The other servers are secondary nodes that keep the data in sync.

If the primary server goes down, the secondary nodes automatically elect a new primary. This ensures high availability without manual intervention.

Load balancing

When dealing with large amounts of data or many concurrent users, a single server can no longer handle the load. MongoDB addresses this with sharding: distributing data across multiple servers, known as shards. Each shard holds a portion of the total dataset.

MongoDB distributes data based on a shard key, a field you choose yourself. A well-chosen shard key ensures an even distribution and optimal performance.

Aggregation

The aggregation pipeline is a powerful tool for processing and analyzing data. You build a pipeline from multiple stages, such as filtering, grouping, sorting, and performing calculations. Each stage processes the output of the previous one.

This makes it possible to run complex analyses directly in the database, without exporting data to an external tool first.

Transactions

For a long time, the lack of multi-document transactions was a frequently heard criticism of MongoDB. Since version 4.0 (2018), however, MongoDB supports full ACID transactions, even across multiple documents and collections.

ACID stands for Atomicity, Consistency, Isolation, and Durability, the four properties that guarantee reliable database operations. This makes MongoDB suitable for applications where data integrity is critical, such as financial systems.

Capped collections

A capped collection is a collection with a fixed maximum size. Once the limit is reached, MongoDB automatically overwrites the oldest documents. This works like a ring buffer.

Capped collections are useful for applications that only need the most recent data, such as log files or activity feeds.

File storage

Through GridFS, MongoDB can store large files that exceed the maximum document size of 16 MB. GridFS splits the file into smaller pieces called chunks and stores each chunk as a separate document. When retrieving the file, the chunks are automatically reassembled.

This makes MongoDB usable as a storage location for images, videos, or other binary files, without needing a separate file system.

MongoDB Atlas

MongoDB Atlas is the fully managed cloud platform from MongoDB, Inc. Instead of installing and maintaining a database yourself, Atlas handles that for you. You choose a cloud provider, a region, and a cluster size, the rest is automatic.

Atlas runs on the three largest cloud platforms: Amazon Web Services (AWS), Google Cloud, and Microsoft Azure. You can choose which region your data is stored in, which matters for performance and privacy regulations like GDPR.

What does Atlas offer?

Atlas takes the operational management of your database completely off your hands. Think automatic backups, security updates, monitoring, and scalability. You do not need server expertise to get started.

In addition to the database itself, Atlas offers several supplementary services. Atlas Search adds powerful search capabilities based on Apache Lucene. Atlas Data Federation allows you to combine and query data from different sources as if it were a single database. And with Atlas Charts, you create data visualizations directly, without an external tool.

Free tier and paid plans

Atlas has a free tier, known as the M0 free tier. It gives you 512 MB of storage and is intended for small projects, prototypes, or learning the platform. For production environments, there are paid plans that scale with your usage.

Pricing is based on the size of your cluster, memory, storage, and data transfer. You only pay for what you use.

Atlas for teams and enterprises

For larger teams, Atlas offers additional capabilities around access management, auditing, and compliance. You can set roles and permissions precisely per user or team. There is also support for private network connections via AWS PrivateLink, Google Cloud Private Service Connect, and Azure Private Link, so your database does not need to be accessible over the public internet.

This makes Atlas suitable not only for individual developers, but also for organizations with strict security requirements.

Comparing MongoDB to other databases

MongoDB is not the only database on the market. Depending on your use case, another solution may be a better fit. Below we compare MongoDB with two widely used alternatives.

MongoDB vs. MySQL

MySQL is one of the most widely used relational databases in the world. It works with tables, fixed schemas, and SQL as its query language. It is mature, well documented, and broadly supported.

MongoDB and MySQL differ fundamentally in how they store and access data. MySQL is strong with structured data that has clear relationships, such as a webshop with customers, orders, and products. MongoDB is better suited when the data structure is flexible or changes frequently.

For many modern web applications, MongoDB is a strong choice. But when working with complex relationships between many different entities, MySQL offers more structure and control.

MongoDB vs. Cassandra

Apache Cassandra is another NoSQL database, but with a different purpose than MongoDB. Cassandra is designed for extremely high write speeds and maximum availability, distributed across multiple data centers. It is used by companies like Netflix and Apple to process enormous volumes of data.

The key difference lies in priorities. Cassandra always favors availability over consistency. MongoDB does the opposite: it prioritizes consistency while still offering high availability through replica sets.

Cassandra is not a replacement for MongoDB and vice versa. Cassandra is the right choice when write speed and global distribution are the top priority. MongoDB is more versatile and easier to use for most applications.

Use cases

MongoDB is deployed across a wide range of industries and applications. The flexible data structure and scalability make it suitable for situations where data changes quickly or is difficult to fit into a fixed schema.

Mobile applications

Mobile apps generate many different types of data: user profiles, location data, preferences, notifications. That data differs per user and changes regularly. MongoDB adapts easily thanks to its flexible document model.

In addition, MongoDB Realm, MongoDB's mobile platform, allows data to be stored locally on the device and automatically synchronized with the cloud. This ensures a smooth user experience, even without an internet connection.

Real-time analytics

Real-time analytics is about processing and analyzing large amounts of data as it comes in. Think about user behavior on a website, sensor data from machines, or transactions in a payment system.

MongoDB is strong here due to the combination of fast write operations and the powerful aggregation pipeline. Analyses are executed directly in the database, minimizing the delay between data collection and insight.

Content management systems

Content management systems (CMS) work with highly varied content types. An article has different fields than a video, a podcast, or a product page. In a relational database, this often means complex table structures or many empty fields.

MongoDB solves this elegantly. Each content type gets its own document structure, without having to adjust the schema of other types. This makes it easier to add new content types as a platform grows.

Enterprise data warehouse

Large organizations store enormous amounts of business data for reporting and analysis. Traditionally this was done in specialized data warehouses based on relational technology. MongoDB offers an alternative for situations where data is diverse and unstructured.

Through Atlas Data Federation, organizations can combine and query data from multiple sources, including S3, Atlas clusters, and other databases, as a single whole. This makes MongoDB a strong component in a modern data architecture.

Pros and cons

MongoDB has a lot to offer, but it is not the best choice for every situation. A fair picture requires both the strengths and the limitations.

Advantages

MongoDB has several properties that set it apart from traditional databases. The flexible schema is the most frequently cited advantage. You can start quickly without a fully worked-out data model, and adjust the structure as your application grows.

Horizontal scalability through sharding makes it possible to process very large datasets without switching to more expensive hardware. This is a major advantage for applications with rapidly growing data volumes.

MongoDB is also broadly supported. There are official drivers for dozens of programming languages, extensive documentation, and a large community. For most problems, a solution or example is easy to find.

Finally, integration with modern development environments is smooth. The JSON-like document format aligns well with JavaScript and many modern frameworks, which lowers the learning curve for web developers.

Disadvantages

Alongside the advantages come limitations. The flexible schema is a benefit, but also a risk. Without discipline or validation rules, a collection can quickly become messy, with inconsistent field names or missing data.

MongoDB is less suitable for applications with many complex relationships between entities. Joins are possible via the $lookup operator, but are less efficient than in a relational database. With heavily relational data, SQL often remains the better choice.

Memory usage is another consideration. MongoDB performs best when a large portion of the working set fits in RAM. On limited hardware, this can become a bottleneck.

Finally, designing a good sharding strategy requires experience. A poor shard key can lead to uneven data distribution and performance issues that are difficult to correct after the fact.

Installation and setup

MongoDB is available for Windows, macOS, and Linux. You can choose between a local installation or getting started directly with MongoDB Atlas in the cloud. For development and small projects, a local installation works fine. For production environments, Atlas is often the faster and more manageable choice.

Installing MongoDB

The easiest way to install MongoDB locally is through the official website: mongodb.com/try/download/community. Here you download the Community Edition, the free version of MongoDB.

On macOS you can also install MongoDB via Homebrew with the following commands:

brew tap mongodb/brew
brew install mongodb-community

On Ubuntu Linux, use the APT package manager. First add the official MongoDB repository, then install the package:

sudo apt-get install -y mongodb-org

After installation, start the MongoDB service with:

sudo systemctl start mongod

In addition to the database itself, it is worth installing MongoDB Compass. This is a graphical interface that lets you visually manage and search databases, collections, and documents without typing commands.

Creating a database

After installation, connect to the database via the mongosh shell. Start the shell with:

mongosh

You are now connected to the local MongoDB instance. Create a new database by navigating to it with the use command:

use myDatabase

MongoDB only actually creates the database once you store data in it. Add a first document to a collection with insertOne:

db.users.insertOne({
  name: "Lisa Baker",
  email: "lisa@example.com",
  age: 28
})

MongoDB confirms the operation and returns the generated _id. The collection users now exists automatically. You can retrieve the stored documents with:

db.users.find()

That is all you need to get started. From here you can expand collections, create indexes, and build queries.

MongoDB as a foundation for modern applications

MongoDB has proven itself over the years as a reliable and versatile database for a wide range of applications. The flexible document model, horizontal scalability, and broad language support make it a strong choice for teams that want to build quickly and grow alongside their data.

It is not a replacement for every relational database. With complex relationships and strict data structures, SQL often remains the better option. But for modern web applications, mobile platforms, real-time analytics, and content-driven systems, MongoDB provides a solid and scalable foundation.

Whether you choose a local installation or MongoDB Atlas in the cloud, the barrier to entry is low. The technology is mature, the community is large, and the documentation is extensive.