Backend for extremely large-scale, cloud-based systems.

MongoDB focuses on enterprise solutions with high configurability and a high degree of flexibility, aiming to provide an answer to almost any scenario.

The drawback of this approach is that to operate a MongoDB database properly, you need a high degree of dedicated expertise to achieve good results.

For that reason, MongoDB recommends MongoDB Atlas (the cloud-hosted version) instead of running MongoDB directly.

db.Orders.find({
    "ShipTo.City": "London"
})

MongoDB queries are using a JSON-based format specific to the database. You'll need to familiarize yourself with the language to effectively use MongoDB.

db.Orders.createIndex({
    "ShipTo.City": 1
})

Requires careful index management for good performance.

With MongoDB, it is the responsibility of the developers (or database administrators) to create the right set of indexes for the queries.

This is a delicate and complex task that requires deep insight into both the system and the database internals. Without careful attention to detail, it is easy to end up with very slow queries.

Fixing these sorts of issues can be costly and complicated.

db.Orders.find({
    "ShipTo.City": "London"
}).sort({ "OrderedAt": -1})
.limit(10)

Some assembly required: you must manually create new compound indexes for added sorting or fields.

db.Orders.createIndex({
    "ShipTo.City": 1,
    "OrderedAt": -1
})

db.Orders.aggregate([{
    "$group": {
        "_id": "$ShipTo.City",
        "Count": { "$sum": 1 }
    }
},
{  "$sort": { "Count": -1 }  },
    {
        "$project": {
            "City": "$_id",
            "Count": 1,
            "_id": 0
    }
}])

In MongoDB, this query runtime is proportional to the amount of records, even if you have the appropriate index. The more Orders you have, the more costly this query is.

Indexes are processed as part of the write operation. More indexes = slower writes. Hard limit of 64 indexes per collection.

db.Employees.find()
.sort({ LastName: 1,
FirstName: 1 })

db.Employees.find()
.sort({ LastName: -1,
FirstName: 1 })

Sort order matters. A simple change in sort direction can force a full collection scan. Separate indexes are often required for each specific sort/query task.

db.Employees.createIndex({
LastName: 1, FirstName: 1 })

db.Employees.createIndex({
LastName: -1, FirstName: 1 })

MongoDB Atlas Vector Search is architecturally a separate service that runs alongside the core database. While it appears seamless via the API, it often involves dedicated Search Nodes in the cloud to handle the heavy lifting calculations.

Runs without any authentication by default. Setting up securely is complex and error-prone (100+ page document). Tens of thousands of instances have been affected by ransomware.

Uses a single primary/multiple secondary model. Writes must go to the primary node. Complex components (config servers, routers, shards). Write scaling requires sharding at the 200 GB mark.

Primary failure means write downtime (often 10+ seconds). Reads fail by default unless specific readConcern settings are used.

// not possible, you need to write
// a full blown program for this

updateMany() is limited. Changes based on a document's own data (e.g., unifying name fields) require writing a separate program to load, modify, and save.

Leaves caching management to the user. Transactions are opt-in. Relies on administrators to manually analyze query patterns and optimize indexes.