Cursor-based pagination (startAfter, endBefore) in Firebase - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ service_behavior

intermediate

Understanding startAfter behavior in Firestore queries

You have a Firestore collection of documents ordered by a timestamp field. You want to fetch the next page of 5 documents after a specific document snapshot using startAfter. What will be the result of the query?

Firebase

const query = firestore.collection('posts').orderBy('createdAt').startAfter(lastDoc).limit(5);
const snapshot = await query.get();
const results = snapshot.docs.map(doc => doc.data());

A The query returns 5 documents strictly after the document represented by lastDoc, excluding lastDoc itself.

B The query returns 5 documents including the document represented by lastDoc.

C The query returns 5 documents before the document represented by lastDoc.

D The query returns all documents in the collection ignoring lastDoc.

💡 Hint

Think about how startAfter works in Firestore pagination.

startAfter excludes the document passed as cursor and returns documents strictly after it, so the page starts after lastDoc.

❓ service_behavior

intermediate

Effect of endBefore in Firestore pagination

You want to fetch the previous page of 5 documents before a specific document snapshot using endBefore. What does the query return?

Firebase

const query = firestore.collection('posts').orderBy('createdAt').endBefore(firstDoc).limitToLast(5);
const snapshot = await query.get();
const results = snapshot.docs.map(doc => doc.data());

A The query returns 5 documents strictly before the document represented by firstDoc, excluding firstDoc.

B The query returns 5 documents including the document represented by firstDoc.

C The query returns all documents in the collection ignoring firstDoc.

D The query returns 5 documents after the document represented by firstDoc.

💡 Hint

Remember how endBefore works with limitToLast in Firestore.

endBefore excludes the document passed as cursor and returns documents strictly before it. Using limitToLast fetches the last N documents before that cursor.

❓ Architecture

advanced

Designing efficient cursor-based pagination for large Firestore collections

You have a Firestore collection with millions of documents. You want to implement cursor-based pagination for a mobile app to load data efficiently. Which approach is best to minimize read costs and latency?

A Fetch all documents at once and paginate on the client side to avoid multiple queries.

B Use <code>orderBy</code> on an indexed field and paginate with <code>startAfter</code> using document snapshots as cursors.

C Use <code>limit</code> without any cursor and fetch the first N documents repeatedly for each page.

D Use <code>orderBy</code> on a non-indexed field and paginate with <code>startAt</code> using field values as cursors.

💡 Hint

Think about Firestore indexing and how cursors work for efficient queries.

Using orderBy on an indexed field with startAfter and document snapshots as cursors allows Firestore to efficiently fetch the next page without scanning all documents.

❓ security

advanced

Securing Firestore cursor-based pagination queries

You want to ensure users can only paginate through documents they have access to in Firestore. Which security rule approach correctly enforces this during cursor-based pagination?

A Use client-side filtering after fetching all documents to enforce access control.

B Write security rules that allow access to all documents in the collection during pagination to avoid errors.

C Disable security rules for pagination queries to improve performance.

D Write security rules that check user permissions on each document individually, regardless of pagination cursors.

💡 Hint

Consider how Firestore security rules apply to queries and documents.

Firestore security rules are evaluated per document. To secure pagination, rules must check permissions on each document returned, regardless of cursors.

✅ Best Practice

expert

Handling inconsistent data during Firestore cursor-based pagination

While paginating through a Firestore collection using startAfter, some documents are added or deleted concurrently. What is the best practice to ensure consistent pagination results?

A Use random ordering to distribute load and avoid conflicts.

B Reload the entire collection on each page request to get the latest data.

C Use a stable, immutable field like a timestamp or unique ID for ordering and cursors to minimize inconsistencies.

D Ignore concurrent changes and rely on client-side merging of results.

💡 Hint

Think about how ordering fields affect pagination stability.

Using a stable, immutable field for ordering and cursors helps maintain consistent pagination even if documents are added or deleted concurrently.