Data modeling best practices in Firebase - Mini Project: Build & Apply

Data Modeling Best Practices with Firebase

📖 Scenario: You are building a simple app to store user profiles and their favorite books using Firebase Firestore. You want to organize your data well so it is easy to read and update.

🎯 Goal: Create a Firebase Firestore data model with collections and documents that follow best practices for structuring user profiles and their favorite books.

📋 What You'll Learn

Create a users collection with user documents

Each user document must have name and email fields

Add a favoriteBooks subcollection inside each user document

Each book document in favoriteBooks must have title and author fields

💡 Why This Matters

🌍 Real World

This data model is useful for apps that store user profiles and their related data, like favorite items or preferences, in a clear and scalable way.

💼 Career

Understanding Firebase data modeling is essential for cloud developers and backend engineers working with NoSQL databases and real-time apps.

1

Create the users collection with user documents

Create a Firebase Firestore data structure with a users collection containing two user documents. Each user document should have the exact fields: name and email. Use the user IDs user1 and user2 with these values: name: "Alice", email: "[e-mail]" for user1 and name: "Bob", email: "[e-mail]" for user2.

Firebase

// Your code here to create users collection with user1 and user2 documents

Hint

Think of users as a collection holding documents named user1 and user2. Each document is an object with name and email.

2

Add a favoriteBooks subcollection for each user

Add a favoriteBooks subcollection inside each user document in the users collection. For now, create empty favoriteBooks objects for both user1 and user2.

Firebase

const users = {
  user1: { name: "Alice", email: "[e-mail]" },
  user2: { name: "Bob", email: "[e-mail]" }
};
// Add empty favoriteBooks subcollections for user1 and user2 below

Hint

Think of favoriteBooks as a small collection inside each user document. Start with empty objects to hold books later.

3

Add book documents inside favoriteBooks subcollections

Inside the favoriteBooks subcollection for user1, add two book documents with IDs book1 and book2. Each book document must have title and author fields. Use these exact values: book1 with title: "1984" and author: "George Orwell", and book2 with title: "Brave New World" and author: "Aldous Huxley". Leave user2's favoriteBooks empty for now.

Firebase

const users = {
  user1: {
    name: "Alice",
    email: "[e-mail]",
    favoriteBooks: {}
  },
  user2: {
    name: "Bob",
    email: "[e-mail]",
    favoriteBooks: {}
  }
};
// Add book1 and book2 documents inside user1's favoriteBooks

Hint

Inside user1.favoriteBooks, add two objects named book1 and book2 with the given fields.

4

Complete the data model with proper nesting

Ensure the entire Firebase Firestore data model is a single JavaScript object named users with user documents containing name, email, and a favoriteBooks subcollection. Confirm that user1 has two book documents and user2 has an empty favoriteBooks subcollection.

Firebase

const users = {
  user1: {
    name: "Alice",
    email: "[e-mail]",
    favoriteBooks: {
      book1: { title: "1984", author: "George Orwell" },
      book2: { title: "Brave New World", author: "Aldous Huxley" }
    }
  },
  user2: {
    name: "Bob",
    email: "[e-mail]",
    favoriteBooks: {}
  }
};
// Verify the complete data model structure

Hint

Review the entire object to confirm all parts are present and correctly nested.

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