Cloud Firestore is a highly scalable NoSQL database, but improper usage can lead to slow queries, high costs, and scalability bottlenecks. This guide covers advanced indexing strategies, query optimization, and cost-efficient techniques to maximize Firestore performance in production.
1. Understanding Firestore’s Performance Fundamentals
How Firestore Handles Reads, Writes, and Indexes
- Reads:
- Document reads are billed per document (not per query).
- Small, frequent reads can be more expensive than batched operations.
- Writes:
- Atomic transactions help maintain consistency but increase latency.
- Batch writes reduce costs and improve performance.
- Indexes:
- Automatic indexing works for simple queries but requires composite indexes for complex filtering.
Key Bottlenecks to Watch
- Hotspots (frequent writes to the same document/collection).
- Inefficient queries (unbounded result sets, lack of indexing).
- Excessive document reads (reading full documents when only a few fields are needed).
2. Optimizing Reads for Speed and Cost Efficiency
A. Use Selective Field Fetching
Instead of retrieving entire documents, fetch only necessary fields:
// Bad: Reads entire document
const snapshot = await db.collection('users').doc('user1').get();
// Good: Fetches only 'name' and 'email'
const snapshot = await db.collection('users').doc('user1').get({
select: ['name', 'email']
});
B. Implement Pagination (Limit & Offset)
Avoid unbounded queries with limit() and startAfter():
const firstPage = await db.collection('posts')
.orderBy('timestamp')
.limit(10)
.get();
const lastVisible = firstPage.docs[firstPage.docs.length - 1];
const nextPage = await db.collection('posts')
.orderBy('timestamp')
.startAfter(lastVisible)
.limit(10)
.get();
C. Use Caching (Firestore Local Cache)
Enable offline persistence to reduce read costs:
// Enable caching in Firebase firebase.firestore().enablePersistence();
3. Optimizing Writes for High Throughput
A. Batch Writes to Reduce Operations
Group multiple writes into a single batch:
const batch = db.batch();
batch.set(db.collection('users').doc('user1'), { name: 'Alice' });
batch.set(db.collection('users').doc('user2'), { name: 'Bob' });
await batch.commit(); // 1 write operation instead of 2
B. Avoid Hotspots with Distributed Counters
For high-frequency counters (e.g., likes, views), shard writes across multiple documents:
// Instead of:
await db.collection('posts').doc('post1').update({
likes: firebase.firestore.FieldValue.increment(1)
});
// Use sharded counters:
const shardId = Math.floor(Math.random() * 10);
await db.collection('posts').doc('post1').collection('likes').doc(`shard_${shardId}`).update({
count: firebase.firestore.FieldValue.increment(1)
});
C. Use Transactions Wisely
Transactions lock documents, so minimize their scope:
const postRef = db.collection('posts').doc('post1');
await db.runTransaction(async (t) => {
const doc = await t.get(postRef);
t.update(postRef, { views: doc.data().views + 1 });
});
4. Advanced Indexing Strategies
A. Create Composite Indexes for Complex Queries
Firestore requires composite indexes for multi-field queries:
// This query requires a composite index on ['category', 'timestamp']
const query = db.collection('products')
.where('category', '==', 'electronics')
.orderBy('timestamp', 'desc')
.limit(10);
To create an index:
- Check Firebase Console → Firestore → Indexes.
- Define the composite index manually if auto-indexing fails.
B. Avoid Expensive Query Patterns
❌ Bad: != (inequality), OR conditions (not natively supported).
✅ Good: Use multiple queries and merge results client-side.
C. Use Collection Group Queries Sparingly
Collection group queries scan all subcollections, increasing cost:
// Searches all 'comments' subcollections (expensive!)
const comments = await db.collectionGroup('comments')
.where('userId', '==', 'user1')
.get();
Optimization: Restrict with where() and limit().
5. Cost Optimization Strategies
A. Monitor and Reduce Read Operations
- Use Firebase Usage Dashboard to track expensive queries.
- Replace real-time listeners with polling where possible.
B. Delete Unused Indexes
- Unused indexes still incur storage costs.
- Audit indexes in Firebase Console → Firestore → Indexes.
C. Use Firestore Emulator for Testing
Before deploying, test queries locally:
firebase emulators:start --only firestore
6. Conclusion
Optimizing Firestore requires smart indexing, efficient queries, and batch operations to balance performance and cost. By following these best practices, you can scale Firestore effectively while minimizing expenses.
Further Reading
