Architecture Overview

5-way philosophy comparison

Head-to-Head Battles

4 deep dives with code & diagrams

Feature Matrix & Scaling

Cross-database comparison table

Positioning

When to compete, when to concede

MongoDB

General-purpose document database. Flexible schema, rich querying, multi-document ACID, horizontal scaling via sharding. Tunable consistency.

CockroachDB

Geo-distributed SQL. Serializable ACID everywhere. PostgreSQL wire protocol. Raft consensus. Designed for global consistency above all else.

ScyllaDB

Raw throughput engine. Shard-per-core architecture. LSM-tree storage. Cassandra-compatible API. Lightweight Transactions only.

EDB Postgres

Enterprise PostgreSQL. Relational + JSONB. Rich extension ecosystem (PostGIS, Citus). Oracle migration path. MVCC concurrency.

DynamoDB

Serverless key-value. Single-digit ms latency at any scale. Access-pattern-driven design. 20 GSI limit. AWS-only.

MongoDB — Single Document

// One document = one atomic unit
db.orders.insertOne({
  customer: "alice",
  items: [
    { sku: "BOOT-42", qty: 1, price: 129.99 },
    { sku: "SOCK-M", qty: 3, price: 12.99 }
  ],
  shipping: { method: "express", addr: {...} },
  total: 168.96
})

Entire order is one document. No joins. Atomic by default.

CockroachDB — Normalized Tables

-- 3 tables, foreign keys, JOINs required
INSERT INTO orders (customer, total)
  VALUES ('alice', 168.96);

INSERT INTO order_items (order_id, sku, qty, price)
  VALUES (1, 'BOOT-42', 1, 129.99),
         (1, 'SOCK-M', 3, 12.99);

INSERT INTO shipping (order_id, method)
  VALUES (1, 'express');

3 tables, 3 inserts, requires a transaction wrapper.

MongoDB — Ad-hoc Querying

// Query any field, any time
db.events.find({
  userId: "u_123",
  type: "click",
  timestamp: { $gte: ISODate("2025-01-01") }
}).sort({ timestamp: -1 })

// New requirement? Just add an index:
db.events.createIndex({ type: 1, timestamp: -1 })

ScyllaDB — Partition-Key Only

-- Table designed for ONE access pattern
CREATE TABLE events_by_user (
  user_id text,
  timestamp timestamp,
  type text,
  PRIMARY KEY (user_id, timestamp)
);

-- Need by type? NEW TABLE:
CREATE TABLE events_by_type (
  type text, timestamp timestamp,
  user_id text,
  PRIMARY KEY (type, timestamp)
);

MongoDB — Natural

db.orders.find({
  "items": {
    $elemMatch: {
      category: "boots",
      price: { $gt: 100 }
    }
  }
})

Reads like the data structure. Works on embedded arrays natively.

PostgreSQL JSONB — Verbose

SELECT * FROM orders
WHERE EXISTS (
  SELECT 1
  FROM jsonb_array_elements(
    data->'items'
  ) AS item
  WHERE item->>'category' = 'boots'
  AND (item->>'price')::numeric > 100
);

Subquery + function call + type casting. Harder to read, write, and maintain.

No Exit Strategy

DynamoDB's data model (partition key + sort key + GSIs) is proprietary. Migration requires rewriting your data layer — not just moving data. No wire-compatible alternative exists.

20 GSI Ceiling

Every access pattern burns a GSI. At 20 you're done. MongoDB has unlimited secondary indexes — create them on the fly without restructuring the data model.

No Search, No Vectors

Full-text search requires OpenSearch (separate service, separate bill). Vector search requires a 3rd-party service. MongoDB Atlas has both built-in.

DynamoDB Shines At

Simple key-value workloads at any scale with zero ops. Serverless microservices on AWS Lambda. Session stores, feature flags, game leaderboards — simple patterns where the 20 GSI limit isn't a concern.

MongoDB's Counter

Atlas Serverless offers zero-ops with multi-cloud flexibility, unlimited indexes, rich querying, ACID transactions, and no vendor lock-in. Same convenience, more capability, more freedom.