Published on

A Comparison of MongoDB and Redis


Recently I spoke very highly of Redis, so I decided to dig deeper and compare it with MongoDB, another DB I've largely ignored. There's probably a reason not everyone uses Redis as a primary DB, this article aims to find out why. I hope you find it useful.


MongoDB is a document-oriented database that uses JSON-like documents with dynamic schemas, making it flexible and easy to query. Redis, on the other hand, is an in-memory data structure store, serving as a more primitive database, cache, and message broker. Both are "modern NoSQL databases", but they excel in different scenarios.

Why does it matter?

The choice of the right database can make or break your project. It directly impacts performance, scalability, and ease of implementation for many features within an app. So let's dive into the details.

Use Cases

MongoDB Shines When:

  • You need a flexible schema that can accommodate evolving data requirements
  • You require rich querying capabilities with support for ad-hoc queries and aggregations
  • You are working on large-scale applications requiring horizontal scaling

Redis Shines When:

  • Low latency, in-memory operations are critical
  • You need a high-performance caching layer to improve the response time of your application
  • Real-time data processing is necessary for your use case (Pub/sub, message queues, etc.)

Alternative Perspectives

Databases are not a one-size-fits-all solution. Here are some alternative perspectives:

  • If you need a relational database with ACID properties, PostgreSQL could be a better fit
  • If you're working on real-time analytics, Cassandra or Apache Spark might offer more features for scaling and performance

Services like RabbitMQ, Kafka, and Amazon SQS are also worth considering for message queuing and event-driven architectures. They offer features like durable message storage, and at-least-once delivery that Redis might not provide out of the box.

A Note on ACID Properties

When first doing research for this article, I stumbled on "ACID" (Atomicity, Consistency, Isolation, Durability). These properties are what define transactional integrity in databases.

MongoDB offers support for ACID transactions within a replica set, meaning it can maintain consistency and isolation across multiple documents. Redis does not offer full ACID compliance. TL;DR: Redis may lose a few writes from time to time. MongoDB won't.

Performance Comparisons


  • Excels at handling large volumes of unstructured data
  • Can handle high concurrency with proper indexing and sharding


  • Offers lightning-fast performance due to its in-memory storage
  • Provides a simple yet powerful API for data manipulation

Real-World Numbers

From this StackOverflow benchmark, using Redis is about 2x faster for writes and 3x faster for reads. You'll have to decide if that's worth the tradeoff.

Making the Most of Each Database


  • Leverage the aggregation framework for complex queries
  • Utilize indexes efficiently to improve query performance
  • Consider horizontal scaling with sharding for high concurrency workloads


  • Use the right data structure for your specific needs (strings, hashes, lists, sets, etc.)
  • Optimize your Redis server configuration for memory usage and performance
  • Consider using Redis as a cache layer in conjunction with another database
  • Leverage Redis for real-time data processing and pub/sub messaging

Practical Tradeoffs

They say the devil is in the details and when starting out with new technologies, it's often hard to see the pitfall until you've been around the block. Here, I'll try to highlight some practical gotchas that might not be immediately obvious when choosing between Redis and MongoDB.


  • It is advised to create a new Redis instance for each application. MongoDB doesn't have this limitation.
  • Nesting data structures in Redis can be complex and error-prone, even with all the nice JSON tools Redis provides.
  • Redis is not a good fit for large datasets, as it's an in-memory database. You'll need to consider the cost of RAM when using Redis.
  • Complex queries are likely going to be more difficult than with MongoDB.


  • It's not going to be as fast as Redis.
  • Redis has better support for real-time updates. MongoDB can listen for changes but I've heard it's not as good. Have yet to try.
  • MongoDB has less sophisticated indexing tools than Redis out of the box.


All DBs are going to have their strengths and weaknesses. Blindly picking one because "I don't want to think about it" is what caused me to miss what Redis had to offer for so long... so stay informed and make the right decision for your next project.

If you've got the time, checkout these other trending databases you might not have heard of: