google_firestore_database cost estimation

A google_firestore_database is a serverless, auto-scaling document database. There's nothing to provision; cost is pure usage: document reads (~$0.06 per 100K), writes (~$0.18 per 100K), deletes (~$0.02 per 100K), and stored data (~$0.18/GB-month), plus a free daily allowance. 10M reads, 2M writes, and 50 GB of storage works out to ~$18.60/month.

The cost is driven entirely by operation volume, and reads usually dominate — a read-heavy app (feeds, dashboards, listings) bills mostly on the read meter. The biggest lever is reducing reads: client and server caching, denormalizing data so one read returns what previously took several, and avoiding re-reading unchanged data. Inefficient query patterns that read whole collections to display a few documents are the classic Firestore overspend.

Writes and deletes are smaller contributors for most apps, and storage is cheap. The free daily tier (50K reads, 20K writes, 20K deletes, 1 GB) covers small/dev workloads entirely.

c3x prices the database from monthly read/write/storage volumes; it's all usage-driven.

Terraform example

A minimal but realistic configuration that C3X can estimate.

resource "google_firestore_database" "main" {
  project     = var.project_id
  name        = "(default)"
  location_id = "us-central1"
  type        = "FIRESTORE_NATIVE"
}

Pricing dimensions

What you actually pay for when you provision google_firestore_database.

Dimension	Unit	What's being charged
Document reads	per 100K reads	Usually the dominant cost for read-heavy apps. Reduced by caching and denormalization. $0.06 per 100K → 10M reads = $6/month
Document writes	per 100K writes	Per 100K document writes. $0.18 per 100K → 2M writes = $3.60/month
Stored data	per GB-month	Document and index storage, billed per GB-month. ~$0.18/GB-month → 50 GB = $9/month

Sample C3X output

10M reads + 2M writes + 50 GB stored in a month:

google_firestore_database.main
├─ Document reads (10M)    100 × 100k-reads    $6.00
├─ Document writes (2M)    20 × 100k-writes    $3.60
└─ Stored data            50 GB-month          $9.00
                          Monthly             $18.60

Optimization tips

Common ways to reduce google_firestore_database cost without changing the workload.

Cache reads aggressively

Proportional to cache hit rate

Reads usually dominate the Firestore bill. Client-side caching (Firestore's offline persistence), a server cache, and not re-reading unchanged data cut the read meter — the single biggest lever for a read-heavy app.

Denormalize to read fewer documents

Proportional to reads eliminated

Each document read is billed. Denormalizing so one read returns what previously took several (embedding summaries, precomputing aggregates) reduces read count directly.

Avoid reading whole collections for a few docs

Large on inefficient query patterns

Query with filters and limits so you read only the documents you display. Reading a whole collection to show a handful is the classic Firestore overspend.

Watch index storage

Per GB-month and write reduced

Composite indexes add storage and write cost. Remove unused indexes and avoid indexing fields you never query on.

FAQ

How is Firestore billed?

By usage, with no instances: document reads (~$0.06/100K), writes (~$0.18/100K), deletes (~$0.02/100K), and storage (~$0.18/GB-month), plus a free daily tier. 10M reads + 2M writes + 50 GB is ~$18.60/month. Reads usually dominate.

Why is my Firestore bill high?

Almost always reads. Read-heavy apps and inefficient query patterns (reading whole collections, re-reading unchanged data) run up the read meter. Caching and denormalizing to read fewer documents is the main fix.

How does c3x estimate the cost?

From monthly read, write, and storage volumes in c3x-usage.yml — it's entirely usage-driven, so there's no instance to price; set your expected operation volumes to model it.

Related resources

Google Cloud

google_bigtable_instance

Node-based NoSQL for very large/high-throughput workloads

`google_firestore_database` cost estimation