How to Reduce Firestore Read Costs and Optimize Query Spending

1import { collection, query, orderBy, limit, startAfter, getDocs } from "firebase/firestore";
2import { db } from "./firebase-config";
3
4const PAGE_SIZE = 20;
5let lastVisible: any = null;
6
7async function loadNextPage() {
8  let q = query(
9    collection(db, "posts"),
10    orderBy("createdAt", "desc"),
11    limit(PAGE_SIZE)
12  );
13
14  if (lastVisible) {
15    q = query(
16      collection(db, "posts"),
17      orderBy("createdAt", "desc"),
18      startAfter(lastVisible),
19      limit(PAGE_SIZE)
20    );
21  }
22
23  const snapshot = await getDocs(q);
24  lastVisible = snapshot.docs[snapshot.docs.length - 1];
25
26  return snapshot.docs.map((doc) => ({
27    id: doc.id,
28    ...doc.data(),
29  }));
30}

1import {
2  collection,
3  query,
4  where,
5  getCountFromServer,
6  getAggregateFromServer,
7  sum,
8  average,
9} from "firebase/firestore";
10import { db } from "./firebase-config";
11
12// Count documents — costs 1 read instead of N reads
13async function getActiveUserCount(): Promise<number> {
14  const q = query(
15    collection(db, "users"),
16    where("status", "==", "active")
17  );
18  const snapshot = await getCountFromServer(q);
19  return snapshot.data().count;
20}
21
22// Sum and average — also 1 read each
23async function getOrderStats() {
24  const q = query(
25    collection(db, "orders"),
26    where("status", "==", "completed")
27  );
28  const snapshot = await getAggregateFromServer(q, {
29    totalRevenue: sum("amount"),
30    averageOrder: average("amount"),
31  });
32  return snapshot.data();
33}

1import { initializeFirestore, persistentLocalCache, persistentMultipleTabManager } from "firebase/firestore";
2import { initializeApp } from "firebase/app";
3
4const app = initializeApp({ /* your config */ });
5
6// Enable persistent cache with multi-tab support
7const db = initializeFirestore(app, {
8  localCache: persistentLocalCache({
9    tabManager: persistentMultipleTabManager(),
10  }),
11});
12
13// Now queries check the local cache first.
14// Real-time listeners receive cached data immediately,
15// then update when server data arrives.
16// One-time reads (getDocs) hit the server by default
17// unless you specify { source: 'cache' }.
18
19import { getDocs, collection, query } from "firebase/firestore";
20
21// Force read from cache only (0 server reads)
22const cached = await getDocs(
23  query(collection(db, "config")),
24  // @ts-ignore — source option
25);

1import { doc, setDoc, serverTimestamp } from "firebase/firestore";
2import { db } from "./firebase-config";
3
4// BAD: Requires 1 read for the post + 1 read for the author = 2 reads per post
5// For a list of 20 posts, that is 40 reads
6
7// GOOD: Denormalize author info onto the post document
8async function createPost(userId: string, userName: string, userAvatar: string, title: string, body: string) {
9  const postRef = doc(collection(db, "posts"));
10  await setDoc(postRef, {
11    title,
12    body,
13    // Denormalized author data — saves 1 read per post display
14    authorId: userId,
15    authorName: userName,
16    authorAvatar: userAvatar,
17    createdAt: serverTimestamp(),
18  });
19}
20
21// Update denormalized data when the source changes
22// Use a Cloud Function triggered by user profile updates
23// to batch-update all posts by that author

1import { collection, query, where, orderBy, limit, onSnapshot } from "firebase/firestore";
2import { db } from "./firebase-config";
3
4// GOOD: Narrow listener — only watches the current user's recent items
5function watchUserTodos(userId: string, callback: (todos: any[]) => void) {
6  const q = query(
7    collection(db, "todos"),
8    where("userId", "==", userId),
9    orderBy("createdAt", "desc"),
10    limit(50)
11  );
12
13  const unsubscribe = onSnapshot(q, (snapshot) => {
14    const todos = snapshot.docs.map((doc) => ({
15      id: doc.id,
16      ...doc.data(),
17    }));
18    callback(todos);
19  });
20
21  return unsubscribe; // Call this when component unmounts
22}
23
24// BAD: Broad listener — watches entire collection
25// onSnapshot(collection(db, "todos"), ...)
26// This reads every document in the collection on initial load

1// Firebase Console: Project Settings > Usage & Billing > Firestore
2// Shows: Document reads, writes, deletes per day
3
4// Google Cloud Console: Billing > Budgets & Alerts
5// Create a budget alert:
6// 1. Go to console.cloud.google.com/billing
7// 2. Click Budgets & alerts > Create budget
8// 3. Set a monthly budget (e.g., $10)
9// 4. Set alert thresholds at 50%, 80%, and 100%
10// 5. Add email recipients
11
12// IMPORTANT: Budget alerts are notifications only.
13// They do NOT cap or stop usage. There is no spending
14// cap on the Blaze plan.
15
16// Firestore audit query in Cloud Functions:
17import { logger } from "firebase-functions";
18logger.info("Firestore read executed", {
19  collection: "posts",
20  operation: "list",
21  limit: 20,
22});