Why Firestore performance needs planning in Firebase - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a Firestore query that limits results to 10 documents.

Firebase

const query = firestore.collection('users').limit([1]);

Drag options to blanks, or click blank then click option'

A'10'

B10

Climit

D100

Attempts:

3 left

💡 Hint

Common Mistakes

Using a string instead of a number for limit

Using a method name instead of a number

The limit method expects a number to limit the number of documents returned. Using 10 returns only 10 documents.

2fill in blank

medium

Complete the code to order users by 'age' for efficient querying.

Firebase

firestore.collection('users').orderBy('[1]');

Drag options to blanks, or click blank then click option'

Aemail

Baddress

Cage

Dname

Attempts:

3 left

💡 Hint

Common Mistakes

Ordering by a field not indexed

Using a field unrelated to the query

Ordering by age requires an index for performance. Firestore uses indexes to speed up queries.

3fill in blank

hard

Fix the error in the Firestore query to avoid performance issues.

Firebase

firestore.collection('users').where('age', '[1]', 30);

Drag options to blanks, or click blank then click option'

A==

Bin

Carray-contains

D!=

Attempts:

3 left

💡 Hint

Common Mistakes

Using unsupported operators without indexes

Using inequality operators that cause full scans

The == operator is used for equality checks and is efficient with indexes. Other operators may cause performance issues if not indexed properly.

4fill in blank

hard

Fill both blanks to create a query that filters users older than 25 and orders by age.

Firebase

firestore.collection('users').where('age', '[1]', 25).orderBy('[2]');

Drag options to blanks, or click blank then click option'

A>

B<

Cage

Dname

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong comparison operator

Ordering by a different field than filtered

Filtering with > 25 and ordering by age ensures efficient queries with proper indexing.

5fill in blank

hard

Fill all three blanks to create a performant Firestore query that filters by city, orders by last name, and limits results.

Firebase

firestore.collection('users').where('city', '==', '[1]').orderBy('[2]').limit([3]);

Drag options to blanks, or click blank then click option'

ANew York

BlastName

C10

DfirstName

Attempts:

3 left

💡 Hint

Common Mistakes

Using a non-indexed field for ordering

Not limiting query results

Filtering by city equals 'New York', ordering by lastName, and limiting to 10 documents improves query speed and reduces costs.

Practice

1. Why is it important to plan Firestore performance before building your app?

easy

A. To increase the number of users automatically

B. To keep the app fast and reduce costs

C. To add more colors to the app interface

D. To make the app look prettier

Solution

1. Step 1: Understand Firestore performance impact

   Firestore charges and speed depend on how data is organized and accessed.

2. Step 2: Connect planning to app speed and cost

   Good planning reduces slow queries and unnecessary reads, keeping the app fast and affordable.

3. Final Answer:

   To keep the app fast and reduce costs -> Option B

4. Quick Check:

   Performance planning = fast app + low cost [OK]

Hint: Think about speed and cost before coding [OK]

Common Mistakes:

• Confusing appearance with performance
• Ignoring cost implications
• Assuming more users means better performance

2. Which Firestore feature helps speed up queries by pre-sorting data?

easy

A. Indexes

B. Security rules

C. Realtime listeners

D. Cloud Functions

Solution

1. Step 1: Identify Firestore features for query speed

   Indexes organize data to make queries faster by pre-sorting and filtering efficiently.

2. Step 2: Match features to their roles

   Security rules protect data, realtime listeners update data live, Cloud Functions run backend code; only indexes speed queries.

3. Final Answer:

   Indexes -> Option A

4. Quick Check:

   Indexes = faster queries [OK]

Hint: Indexes speed queries by sorting data [OK]

Common Mistakes:

• Confusing security rules with indexes
• Thinking realtime listeners speed queries
• Assuming Cloud Functions affect query speed

3. Given this Firestore query:
db.collection('users').where('age', '>', 18).orderBy('age').limit(5)
What is a key reason this query performs well?

medium

A. It reads all users without filters

B. It fetches data without any conditions

C. It orders by a field not indexed

D. It uses a limit to reduce data read

Solution

1. Step 1: Analyze query filters and limits

   The query filters users older than 18, orders by age, and limits results to 5, reducing data read.

2. Step 2: Understand impact on performance

   Using limit reduces the number of documents fetched, making the query faster and cheaper.

3. Final Answer:

   It uses a limit to reduce data read -> Option D

4. Quick Check:

   Limit reduces data read = better performance [OK]

Hint: Limit queries to reduce data read [OK]

Common Mistakes:

• Ignoring the effect of limit
• Assuming no filters means better speed
• Not considering index usage

4. You wrote this Firestore query:
db.collection('orders').where('status', '==', 'shipped').orderBy('date')
But it throws an error about missing index. What should you do?

medium

A. Create a composite index on 'status' and 'date'

B. Remove the orderBy clause

C. Change 'status' to 'date' in where clause

D. Use a realtime listener instead

Solution

1. Step 1: Understand Firestore index requirements

   Queries with filters and orderBy on different fields need a composite index to work.

2. Step 2: Fix the error by creating the needed index

   Creating a composite index on 'status' and 'date' satisfies Firestore's requirement and removes the error.

3. Final Answer:

   Create a composite index on 'status' and 'date' -> Option A

4. Quick Check:

   Composite index fixes missing index error [OK]

Hint: Create composite indexes for combined filters and sorting [OK]

Common Mistakes:

• Removing orderBy without reason
• Changing filter fields incorrectly
• Using realtime listeners to fix index errors

5. You want to design a Firestore database for a chat app with many users and messages. Which planning step improves performance best?

hard

A. Store messages in a single document per user to reduce reads

B. Store all messages in one big collection and query by user ID

C. Split messages into subcollections per chat room and index user ID

D. Avoid using indexes to save costs

Solution

1. Step 1: Consider data organization for scalability

   Storing messages in subcollections per chat room groups related data and limits query scope.

2. Step 2: Use indexes to speed up user-specific queries

   Indexing user ID in subcollections allows fast queries without scanning all messages.

3. Final Answer:

   Split messages into subcollections per chat room and index user ID -> Option C

4. Quick Check:

   Organize data + index fields = better performance [OK]

Hint: Group data by chat room and index user ID [OK]

Common Mistakes:

• Putting all messages in one collection causing slow queries
• Storing all messages in one document causing size limits
• Skipping indexes to save money but hurting speed