MongoDB Atlas vs Google Firestore vs AWS DynamoDB: Real Document Database Cost per 100 Million Operations in 2026
The short answer: only two of these three platforms bill the operation itself. Firestore charges per document read, write and delete, and DynamoDB On-Demand charges per request unit scaled by item size. MongoDB Atlas does neither at this scale: a 100 GB dataset does not fit Atlas's usage-priced Flex tier (capped at 5 GB), so the workload lands on a dedicated cluster billed by the hour for its tier, and the same cluster costs the same whether it serves 10 million or 400 million operations. At an illustrative 2 KB document size and a 120 GB footprint (data plus indexes), 100 million operations cost about $54 on Firestore (regional) and about $54–$60 on DynamoDB in a 90%-read scenario, and about $78 on Firestore and $127–$130 on DynamoDB in a 50/50 scenario. A comparable Atlas dedicated cluster is reported at about $759 a month for the M40 tier (more if the listed rate is per node), before backup and storage expansion. The per-operation platforms are cheap at this volume; their risk is that cost scales linearly with traffic, while Atlas's cost scales with the cluster you must provision.
The billing-unit mismatch, up front
Firestore Standard bills a document read, a document write and a document delete, regardless of size (within limits), and separately bills storage including index storage. Firestore Enterprise edition instead bills read units (4 KiB tranches) and write units (1 KiB tranches, with each index entry written consuming further units). DynamoDB On-Demand bills read request units (one per 4 KB strongly consistent read, half that for eventually consistent) and write request units (one per 1 KB written), so a 2 KB item costs two write units and a global secondary index adds more. MongoDB Atlas does not bill operations on its dedicated tiers; it bills cluster-hours by tier, with RAM, vCPU and default storage fixed per tier. Its Flex tier is the exception, priced by operations per second ceiling. "100 million logical operations" therefore means three different things in three different invoices.
What each vendor actually bills
MongoDB Atlas (OFFICIAL for tier structure; REPORTED for dedicated-tier hourly rates). The Serverless and shared M2/M5 tiers have been deprecated and replaced by Flex: $8 a month base (100 ops/second, 5 GB storage included), scaling in steps to $15 (200 ops/s) and $30 (500 ops/s), where the bill is capped at $30. Older guides that cite Serverless "read processing units" describe a product no longer sold to new clusters. Dedicated clusters start at about $0.08 an hour ($57 a month) for M10 and are priced by tier: an M40 is reported at about $759 a month (roughly $1.04 an hour, 80 GB default storage, 16 GB RAM), an M50 at about $2,000. One third-party source states that the listed hourly rate applies per node and that a standard three-node replica set therefore triples it (about $2,277 for M40); Atlas's own calculator is the place to confirm whether the listed figure covers all three nodes. Backup storage is billed separately (reported around $0.14/GB-month), as is data transfer and Atlas Search.
Google Firestore (OFFICIAL, cloud.google.com/firestore/pricing, us-central1 and nam5). Standard edition, regional (us-central1): $0.30 per million reads, $0.90 per million writes, $0.10 per million deletes, $0.15/GiB-month storage. Multi-region (nam5): $0.60 per million reads, $1.80 per million writes, $0.18/GiB-month — twice the operation price. Free quota per day: 50,000 reads, 20,000 writes, 20,000 deletes and 1 GiB storage. Enterprise edition (us-central1): $0.05 per million read units and $0.26 per million write units, with index entries consuming write units (1 write unit per 1 KiB of index entry) and real-time updates on a separate $0.30-per-million-read-units SKU. Standard edition does not charge operations for index maintenance, but index entries consume storage; some aggregation queries read many index entries per document returned.
AWS DynamoDB (OFFICIAL, AWS DynamoDB pricing, On-Demand). $0.625 per million write request units, $0.125 per million read request units; storage $0.25/GB-month (the first 25 GB per account is free, excluded here). One RRU covers one strongly consistent read up to 4 KB (two eventually consistent reads); one WRU covers one write up to 1 KB. Each global secondary index is a separate write destination, billed in write units for the projected item size, and a separate storage charge. Global Tables bill replicated writes in each region and are not modeled.
Normalizing the workload
All ILLUSTRATIVE. 100 million logical operations a month; Scenario A: 90M reads / 10M writes; Scenario B: 50M reads / 50M writes; average document or item size 2 KB; 120 GB billed footprint (100 GB of documents plus roughly 20 GB of index overhead, applied equally to every platform); no deletes; one secondary index. Conversions: DynamoDB — a 2 KB write is 2 WRU on the table plus 1 WRU on the index (3 total); a 2 KB strongly consistent read is 1 RRU, an eventually consistent one 0.5 RRU. Firestore Enterprise — a 2 KB document read is 1 read unit; a 2 KB write is 2 write units plus an ILLUSTRATIVE 3 index-entry units (5 total). Free tiers are excluded throughout. The average rate is about 38 operations per second, comfortably within every platform's published capacity.
Cost at the normalized workload
Formulas: Firestore = reads ÷ 1M × read rate + writes ÷ 1M × write rate + GiB × storage rate; DynamoDB = reads × RRU ÷ 1M × $0.125 + writes × 3 WRU ÷ 1M × $0.625 + GB × $0.25; Atlas = hourly tier rate × 730, independent of operations.
| Platform | Scenario A (90% reads) | Scenario B (50% reads) |
|---|---|---|
| Firestore Standard, regional (us-central1) | $54.00 ($27 reads + $9 writes + $18 storage) | $78.00 ($15 + $45 + $18) |
| Firestore Standard, multi-region (nam5) | $93.60 ($54 + $18 + $21.60) | $141.60 ($30 + $90 + $21.60) |
| Firestore Enterprise (operations only; storage rate not included) | $17.50 ($4.50 reads + $13 writes) | $67.50 ($2.50 + $65) |
| DynamoDB On-Demand, eventually consistent reads | $54.38 ($5.63 + $18.75 + $30) | $126.88 ($3.13 + $93.75 + $30) |
| DynamoDB On-Demand, strongly consistent reads | $60.00 ($11.25 + $18.75 + $30) | $130.00 ($6.25 + $93.75 + $30) |
| MongoDB Atlas M40 dedicated (REPORTED list rate; before backup and storage beyond 80 GB) | $759 | $759 |
| MongoDB Atlas M40 if the listed rate is per node (REPORTED, unconfirmed) | $2,278 | $2,278 |
Atlas's M40 is an ILLUSTRATIVE sizing: it is the reported tier whose default storage (80 GB) is closest to the 120 GB footprint, not a claim that it is the minimum cluster that serves this traffic. Atlas Flex would cover 38 operations a second on its $8 base, but its 5 GB storage cap rules it out for this dataset.
Why Atlas does not move with operations, and the others do
Formula: per-operation platforms' cost = traffic × unit price + storage; Atlas dedicated cost = tier price, until the tier is outgrown. In the 90/10 mix, at a tenth of this workload (10 million operations) Firestore regional would cost about $21.60 and DynamoDB (strongly consistent) about $33, because storage dominates, while the Atlas cluster would still cost $759. At ten times this workload (1 billion operations) Firestore would cost about $378 and DynamoDB about $330, while Atlas would remain $759 as long as the M40's RAM and throughput hold. The volume at which the reported M40 list price equals the per-operation bill is roughly 2.1 billion operations a month for Firestore regional and 2.4 billion for DynamoDB in the 90/10 mix, but only about 1.2 billion and 0.7 billion respectively in the 50/50 mix, so the crossover moves by a factor of three with write share alone.
The write-share and index effects
Write share matters more than total volume on the per-operation platforms. Moving from 10% to 50% writes raises DynamoDB's operation cost roughly fourfold (from $24 to $97 for eventually consistent reads) because writes cost five times a read unit and, here, three units each. On Firestore Enterprise the same shift takes operations from $17.50 to $67.50, mostly because index entries consume write units. Standard edition avoids operation charges on index writes, but pays for the index in storage. A document with a 100-element indexed array creates 100 index entries per write, which on Firestore multiplies storage and on DynamoDB multiplies write units for every index that projects it.
Sensitivity
- Item or document size. A 4 KB item doubles DynamoDB's write units and, for strongly consistent reads, leaves read units unchanged at one per 4 KB; Firestore Standard is size-insensitive for ordinary documents, which favours it for larger documents and DynamoDB for small ones.
- Write share and index count. Raises DynamoDB and Firestore Enterprise bills much faster than their read-heavy cost, and has no effect on an Atlas cluster until it saturates.
- Regional versus multi-region (Firestore). Multi-region doubles per-operation prices and raises storage by 20%, taking Scenario A from $54 to $93.60.
- Consistency mode (DynamoDB). Eventually consistent reads cost half as much per read, which at a 90% read share trims the bill by about $5.60 here, but matters more as read volume grows.
Budgeting traps
- Pricing Atlas from Serverless-era "read processing unit" rates. Those tiers were deprecated; current usage pricing exists only on Flex, and Flex ends at 5 GB and $30.
- Treating one logical operation as one DynamoDB request unit. At 2 KB, a write is already three units with one index.
- Assuming Firestore's cheap regional rates apply to multi-region. The multi-region rates are double.
- Ignoring index storage and index fan-out. It is a storage cost on Firestore Standard and an operations cost on Firestore Enterprise and DynamoDB.
- Comparing an Atlas cluster price to per-operation bills at low volume. The cluster is a fixed floor, not a unit price.
What to ask before you buy
Ask Atlas to confirm in its calculator whether the listed hourly rate for your tier covers a full replica set, and what storage expansion and backup add for your footprint. Measure your actual average document size, index count and read/write ratio before using any per-operation figure, and confirm Firestore's price for your exact region (multi-region and some single regions differ from us-central1).