Data modeling best practices in Firebase - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Choosing the right data structure in Firebase

You want to store user profiles in Firebase Realtime Database. Which data structure is best to allow quick access to each user by their unique ID?

A Store user profiles as a dictionary where each key is the user ID and the value is the profile data.

B Store user profiles in separate databases for each user.

C Store user profiles as a single string with all profiles concatenated.

D Store all user profiles in a list where each profile is an item without keys.

💡 Hint

Think about how you can quickly find a user profile by ID without scanning all data.

Using a dictionary with user IDs as keys allows direct access to each profile without scanning a list, making reads efficient.

❓ Architecture

intermediate

Avoiding data duplication in Firebase

You have a list of products and a list of orders referencing those products. What is the best way to model this to avoid duplicating product details in each order?

A Store product IDs inside orders and keep product details in a separate products collection.

B Store full product details inside each order entry.

C Store orders inside each product entry.

D Duplicate product details in both products and orders collections.

💡 Hint

Think about how to keep data consistent and avoid repeating the same information.

Referencing product IDs in orders and keeping product details separately avoids duplication and keeps data consistent.

❓ security

advanced

Securing nested data in Firebase Realtime Database

You want to restrict write access so users can only update their own profile data nested under /users/{userId}. Which Firebase Realtime Database rule correctly enforces this?

A

{
  "rules": {
    "users": {
      "$userId": {
        ".write": "true"
      }
    }
  }
}

B

{
  "rules": {
    "users": {
      "$userId": {
        ".write": "auth != null"
      }
    }
  }
}

C

{
  "rules": {
    "users": {
      "$userId": {
        ".write": "auth.uid == 'admin'"
      }
    }
  }
}

D

{
  "rules": {
    "users": {
      "$userId": {
        ".write": "auth != null && auth.uid == $userId"
      }
    }
  }
}

💡 Hint

Users should only write to their own user ID path, not others.

Rule D checks that the user is authenticated and their ID matches the userId in the path, restricting writes properly.

❓ service_behavior

advanced

Understanding Firebase Realtime Database event triggers

What happens when you attach a listener to /messages that triggers on child_added event?

A The listener triggers every time any child under /messages is changed or removed.

B The listener triggers once for each existing child under /messages and then for every new child added.

C The listener triggers only once when the first child is added under /messages.

D The listener triggers only once when the listener is attached.

💡 Hint

Think about how Firebase sends data when you first attach a listener.

The child_added event fires once for each existing child at the time of attachment, then for every new child added afterward.

✅ Best Practice

expert

Optimizing Firebase data structure for scalability

You have a chat app with thousands of users and millions of messages. Which data modeling approach best supports fast queries and scalability?

A Store all messages in a single list under <code>/messages</code> with no further nesting.

B Store messages as separate top-level nodes with random keys and no grouping.

C Nest messages under each chat room ID, e.g., <code>/chatRooms/{roomId}/messages</code>, and paginate queries by timestamp.

D Store all messages inside each user's profile to keep data together.

💡 Hint

Think about how to limit data downloaded and keep queries efficient.

Nesting messages under chat rooms and paginating by timestamp limits data size per query and improves scalability.

Practice

1. What is the main reason to use collections and documents in Firestore for data modeling?

easy

A. To make data read-only for all users

B. To store all data in one big JSON object

C. To avoid using any security rules

D. To organize data in a way that is easy to query and scale

Solution

1. Step 1: Understand Firestore structure

   Firestore organizes data into collections and documents to keep data structured and easy to access.

2. Step 2: Benefits of collections and documents

   This structure allows efficient queries and scaling as your app grows.

3. Final Answer:

   To organize data in a way that is easy to query and scale -> Option D

4. Quick Check:

   Firestore uses collections/documents for scalable data [OK]

Hint: Think of collections as folders and documents as files [OK]

Common Mistakes:

• Thinking all data should be in one JSON object
• Ignoring the need for security rules
• Assuming data is read-only by default

2. Which of the following is the correct way to reference a document in Firestore?

easy

A. db.users('user123')

B. db.collection('users').doc('user123')

C. db.get('users/user123')

D. db.document('users').collection('user123')

Solution

1. Step 1: Recall Firestore syntax

   Firestore uses collection() to select a collection and doc() to select a document.

2. Step 2: Check each option

   db.collection('users').doc('user123') correctly uses collection('users').doc('user123'). Others do not follow Firestore syntax.

3. Final Answer:

   db.collection('users').doc('user123') -> Option B

4. Quick Check:

   Firestore document reference uses collection().doc() [OK]

Hint: Remember: collection() then doc() for Firestore paths [OK]

Common Mistakes:

• Using incorrect method names like get() or document()
• Swapping collection and document order
• Trying to access documents directly from db without collection

3. Given this Firestore data model:

users (collection)
  user123 (document)
    name: 'Alice'
    posts (collection)
      post1 (document)
        title: 'Hello'

What will db.collection('users').doc('user123').collection('posts').get() return?

medium

A. A list of all posts documents under user123

B. An error because posts is not a field

C. Only the user123 document data

D. All users documents with their posts

Solution

1. Step 1: Understand nested collections

   In Firestore, collections can be nested under documents. Here, posts is a subcollection under user123.

2. Step 2: What does the query do?

   The query gets all documents in the posts collection under user123, so it returns all posts documents.

3. Final Answer:

   A list of all posts documents under user123 -> Option A

4. Quick Check:

   Subcollections return their documents on get() [OK]

Hint: Subcollections are accessed by chaining collection().doc().collection() [OK]

Common Mistakes:

• Thinking subcollections are fields inside documents
• Expecting get() to return parent document data
• Assuming get() returns all users and posts together

4. You have this Firestore security rule snippet:

match /users/{userId} {
  allow read, write: if request.auth.uid == userId;
}

What is the main issue if you want users to read their posts stored in a subcollection posts under their user document?

medium

A. The rule does not cover the posts subcollection, so access is denied

B. The rule allows anyone to read posts

C. The rule allows write but not read

D. The rule only works for admin users

Solution

1. Step 1: Analyze the rule scope

   The rule matches only the /users/{userId} document, not any subcollections like posts.

2. Step 2: Effect on subcollections

   Without explicit rules for /users/{userId}/posts/{postId}, access to posts is denied by default.

3. Final Answer:

   The rule does not cover the posts subcollection, so access is denied -> Option A

4. Quick Check:

   Security rules must cover subcollections explicitly [OK]

Hint: Rules must match subcollections separately to allow access [OK]

Common Mistakes:

• Assuming parent document rules apply to subcollections
• Believing rules allow all reads by default
• Confusing read and write permissions

5. You want to design a Firestore data model for a chat app where users can have many messages. Which approach follows best practices for scalability and easy querying?

hard

A. Store all messages in a single collection with a userId field to filter messages

B. Store messages as an array field inside each user document

C. Create a messages subcollection under each user document

D. Store messages in a single document with nested objects for each message

Solution

1. Step 1: Consider scalability needs

   Storing many messages inside one document or array can cause size limits and slow queries.

2. Step 2: Use subcollections for many related items

   Creating a messages subcollection under each user document allows efficient queries and scales well.

3. Final Answer:

   Create a messages subcollection under each user document -> Option C

4. Quick Check:

   Use subcollections for large, related data sets [OK]

Hint: Use subcollections for many related items to avoid document size limits [OK]

Common Mistakes:

• Putting many items in arrays inside documents
• Using one big collection without filtering
• Storing all data in one document causing size errors