Query optimization in Firebase - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ service_behavior

intermediate

Understanding Firestore Query Index Requirements

You have a Firestore collection with documents containing fields: age (number), city (string), and status (string). You run this query:
collection.where('age', '>', 25).where('city', '==', 'Seattle').orderBy('status')
What will happen when you run this query without any additional setup?

A The query fails with an error asking to create a composite index.

B The query runs successfully without any errors.

C The query returns documents but ignores the orderBy clause.

D The query returns documents but only filters by age.

💡 Hint

Firestore requires composite indexes for queries with multiple where filters and orderBy on different fields.

Firestore needs a composite index when you combine multiple where filters with an orderBy on a different field. Without it, the query fails and prompts you to create the index.

❓ Architecture

intermediate

Optimizing Firestore Queries for Large Collections

You have a Firestore collection with millions of documents. You want to efficiently fetch documents where status is 'active' and order them by createdAt descending. Which approach is best to optimize query performance?

A Use multiple queries for each status value and merge results in the app.

B Use a query with where('status', '==', 'active') and orderBy('createdAt', 'desc') with a composite index on status and createdAt.

C Use orderBy('createdAt', 'desc') only and filter status after fetching.

D Fetch all documents and filter 'active' status in your application code.

💡 Hint

Filtering and ordering in the query with proper indexes is more efficient than client-side filtering.

Using a composite index on status and createdAt allows Firestore to efficiently filter and order documents server-side, reducing data transfer and latency.

❓ security

advanced

Securing Firestore Queries with Rules and Indexes

You want to allow users to query their own orders by userId and filter by orderStatus. You create a composite index on userId and orderStatus. Which Firestore security rule best ensures users can only query their own orders?

A allow read: if request.auth.token.admin == true;

B allow read: if request.auth.uid != null;

C allow read: if resource.data.orderStatus == 'completed';

D allow read: if request.auth.uid == resource.data.userId;

💡 Hint

Security rules should restrict access based on user identity matching document fields.

Rule A restricts reads to documents where the userId matches the authenticated user's ID, ensuring users only access their own orders.

✅ Best Practice

advanced

Reducing Firestore Query Costs with Pagination

You have a Firestore query that returns thousands of documents. To reduce cost and improve performance, what is the best practice to paginate results?

A Use offset() to skip documents and limit() to fetch pages.

B Fetch all documents at once and slice the results in the client.

C Use limit() with startAfter() or startAt() cursors to fetch pages incrementally.

D Run multiple queries with different where filters to split data.

💡 Hint

Firestore charges for documents read, so fetching only needed documents is best.

Using limit() with cursors like startAfter() fetches only the needed documents per page, reducing reads and cost. Using offset() still reads skipped documents, increasing cost.

🧠 Conceptual

expert

Analyzing Firestore Query Execution Behavior

Consider a Firestore collection with documents having fields: category, price, and rating. You run this query:
collection.where('category', '==', 'books').orderBy('price').orderBy('rating')
Which statement best describes how Firestore executes this query?

A Firestore uses a composite index on category, price, and rating to efficiently filter and order results.

B Firestore orders by price only and ignores the rating orderBy clause.

C Firestore filters by category first, then orders by price and rating without needing an index.

D Firestore requires separate queries for price and rating ordering.

💡 Hint

Multiple orderBy clauses require a composite index covering all fields in order.

Firestore requires a composite index that includes all where and orderBy fields in the correct order to execute such queries efficiently.

Practice

1. What is the main benefit of using query optimization in Firebase?

easy

A. It makes your app faster and reduces costs by fetching only needed data.

B. It automatically backs up your database.

C. It increases the size of your database.

D. It disables security rules temporarily.

Solution

1. Step 1: Understand query optimization purpose

   Query optimization aims to improve performance and reduce costs by limiting data fetched.

2. Step 2: Identify correct benefit

   Only "It makes your app faster and reduces costs by fetching only needed data." describes faster app and cost reduction by fetching needed data.

3. Final Answer:

   It makes your app faster and reduces costs by fetching only needed data. -> Option A

4. Quick Check:

   Query optimization = faster app and lower cost [OK]

Hint: Optimization means fetching only what you need [OK]

Common Mistakes:

• Thinking optimization backs up data
• Assuming optimization increases database size
• Confusing optimization with security settings

2. Which Firebase query syntax correctly limits results to 10 documents ordered by 'score'?

easy

A. db.collection('games').orderBy('score').limit(10)

B. db.collection('games').limit(10).orderBy('score')

C. db.collection('games').where('score', '==', 10).orderBy('score')

D. db.collection('games').orderBy('score', 10)

Solution

1. Step 1: Check correct method order

   In Firebase, orderBy must come before limit to sort then limit results.

2. Step 2: Validate syntax correctness

   db.collection('games').orderBy('score').limit(10) uses correct chaining: orderBy('score').limit(10). Others misuse order or parameters.

3. Final Answer:

   db.collection('games').orderBy('score').limit(10) -> Option A

4. Quick Check:

   orderBy then limit = correct syntax [OK]

Hint: Always orderBy before limit in Firebase queries [OK]

Common Mistakes:

• Placing limit before orderBy
• Using where instead of limit for count
• Passing number as second orderBy argument

3. Given this query:

db.collection('users').where('age', '>=', 18).orderBy('age').limit(3)

What will this query return?

medium

A. All users younger than 18.

B. An error because orderBy and where fields differ.

C. The first 3 users aged 18 or older, ordered by age ascending.

D. The last 3 users regardless of age.

Solution

1. Step 1: Analyze where and orderBy fields

   Both where and orderBy use 'age', which is allowed and required for range filters.

2. Step 2: Understand limit effect

   Limit(3) returns only first 3 documents matching criteria ordered by age ascending.

3. Final Answer:

   The first 3 users aged 18 or older, ordered by age ascending. -> Option C

4. Quick Check:

   where and orderBy on same field + limit = first 3 matching [OK]

Hint: where range and orderBy must use same field [OK]

Common Mistakes:

• Thinking it returns users younger than 18
• Assuming error due to different fields
• Ignoring limit effect

4. You wrote this query:

db.collection('orders').where('status', '==', 'shipped').orderBy('date')

But it throws an error about missing index. What should you do?

medium

A. Remove orderBy to fix the error.

B. Create a composite index on 'status' and 'date' fields in Firebase console.

C. Change '==' to '>=' in where clause.

D. Use limit(1) to avoid indexing.

Solution

1. Step 1: Understand composite index requirement

   Queries with where and orderBy on different fields need a composite index in Firebase.

2. Step 2: Fix error by creating index

   Creating a composite index on 'status' and 'date' fields resolves the error.

3. Final Answer:

   Create a composite index on 'status' and 'date' fields in Firebase console. -> Option B

4. Quick Check:

   Missing index error = create composite index [OK]

Hint: Missing index error means create composite index [OK]

Common Mistakes:

• Removing orderBy instead of indexing
• Changing operators incorrectly
• Using limit to bypass index requirement

5. You want to optimize a query to fetch only active users with scores above 50, ordered by score descending, limited to 5 results. Which query is best?

hard

A. db.collection('users').where('active', '==', true).orderBy('score').limit(5)

B. db.collection('users').orderBy('score', 'desc').limit(5).where('active', '==', true).where('score', '>', 50)

C. db.collection('users').where('score', '>', 50).limit(5).orderBy('score', 'desc').where('active', '==', true)

D. db.collection('users').where('active', '==', true).where('score', '>', 50).orderBy('score', 'desc').limit(5)

Solution

1. Step 1: Check correct chaining and order

   db.collection('users').where('active', '==', true).where('score', '>', 50).orderBy('score', 'desc').limit(5) correctly chains where filters first, then orderBy with descending, then limit.

2. Step 2: Validate query logic

   It filters active users with score > 50, orders by score descending, and limits to 5 results as required.

3. Final Answer:

   db.collection('users').where('active', '==', true).where('score', '>', 50).orderBy('score', 'desc').limit(5) -> Option D

4. Quick Check:

   Filter then orderBy desc then limit = optimized query [OK]

Hint: Chain where filters before orderBy and limit [OK]

Common Mistakes:

• Placing limit before where
• Incorrect orderBy direction
• Missing one of the filters