Firebase Firestore Read/Write Bill Shock Simulator

// firestore-cache-wrapper.ts - Defend against runaway document read costs
import { getFirestore, doc, getDoc } from 'firebase-admin/firestore';
import { Redis } from 'ioredis';

const db = getFirestore();
const redis = new Redis(process.env.REDIS_URL!);

export async function getCachedDocument(collection: string, docId: string, ttlSeconds = 300): Promise {
  const cacheKey = `firestore:${collection}:${docId}`;
  
  // Step 1: Check in-memory Redis cache (Sub-millisecond & $0 read fee)
  const cached = await redis.get(cacheKey);
  if (cached) {
    return JSON.parse(cached);
  }

  // Step 2: Fall back to Firestore (Consumes 1 billed read operation)
  const snap = await db.collection(collection).doc(docId).get();
  if (!snap.exists) {
    throw new Error('Document not found');
  }

  const data = snap.data() as T;
  // Step 3: Cache for 5 minutes with jitter
  await redis.set(cacheKey, JSON.stringify(data), 'EX', ttlSeconds);
  return data;
}

Cloud Firestore Architecture: Read/Write Metering & Bill Shock Mitigation

Google Cloud Firestore charges directly for every document operation: Reads ($0.06 per 100,000 documents), Writes ($0.18 per 100,000 documents), and Deletes ($0.02 per 100,000 documents). While these rates appear minimal, binding real-time client listeners (`onSnapshot`) to large collections or rendering un-paginated lists of 10,000 documents to active web users multiplies reads exponentially: a single active user viewing an updating feed of 500 documents can trigger 50,000 reads in minutes, resulting in four-figure cloud invoices.

Production Pipeline: Cursor-Based Pagination & Local Cache Strategy

Implementing cursor-based pagination with `startAfter` and enabling Firestore persistent indexedDB offline caching eliminates redundant document read billing:

import { collection, query, orderBy, startAfter, limit, getDocs } from 'firebase/firestore';
import { db } from './firebaseConfig';

export async function fetchPaginatedFeed(lastVisibleDoc: any, pageSize: number = 20) {
  let q;
  if (lastVisibleDoc) {
    q = query(
      collection(db, 'posts'),
      orderBy('createdAt', 'desc'),
      startAfter(lastVisibleDoc),
      limit(pageSize)
    );
  } else {
    q = query(
      collection(db, 'posts'),
      orderBy('createdAt', 'desc'),
      limit(pageSize)
    );
  }

  const documentSnapshots = await getDocs(q);
  const items = documentSnapshots.docs.map(doc => ({ id: doc.id, ...doc.data() }));
  const lastDoc = documentSnapshots.docs[documentSnapshots.docs.length - 1];
  
  return { items, lastDoc };
}

Production Best Practices & Quota Checklist

• Use Count() Aggregation Queries: Calculating collection size by downloading all documents incurs 1 read per document. Use Firestore's native `count()` aggregation API, which bills only 1 read per 1,000 counted index entries.
• Bundle Counters into Parent Documents: Rather than querying an entire subcollection of likes or comments, maintain a denormalized `commentCount` integer field on the parent document updated via Cloud Functions.
• Configure Hard GCP Budget Caps: In Google Cloud Billing, create a programmatic budget alert with Cloud Pub/Sub that automatically disables billing or revokes Firebase project API keys if daily spend exceeds $100.