Why Firestore is Firebase's primary database - Why It Works This Way

Overview - Why Firestore is Firebase's primary database

What is it?

Firestore is a cloud database service provided by Firebase that stores and syncs data for mobile and web apps in real time. It is designed to be easy to use, scalable, and flexible, allowing developers to build apps that update instantly across devices. Firestore organizes data in documents and collections, making it simple to structure and query information.

Why it matters

Before Firestore, developers struggled with databases that were either hard to scale or difficult to keep in sync across users and devices. Firestore solves this by providing a real-time, scalable database that automatically updates data everywhere. Without Firestore, apps would be slower, less responsive, and harder to build, especially when users expect instant updates.

Where it fits

Learners should first understand basic database concepts like tables, records, and queries. After Firestore, they can explore advanced topics like offline data handling, security rules, and integration with other Firebase services like Authentication and Cloud Functions.

Mental Model

Core Idea

Firestore is a real-time, cloud-hosted database that keeps app data synced instantly across all users and devices.

Think of it like...

Imagine a shared whiteboard in a classroom where everyone can write or erase notes at the same time, and all students see the changes immediately no matter where they sit.

┌───────────────┐       ┌───────────────┐       ┌───────────────┐
│   Device A    │──────▶│   Firestore   │◀──────│   Device B    │
│ (User writes) │       │ (Cloud sync)  │       │ (User reads)  │
└───────────────┘       └───────────────┘       └───────────────┘

Changes made on any device update Firestore, which instantly syncs to all other devices.

Build-Up - 7 Steps

1

Foundation

Understanding Cloud Databases

Concept: Introduce what a cloud database is and why it differs from local storage.

A cloud database stores data on internet servers instead of on your device. This means your app can access the same data from anywhere, and multiple users can share and update data together.

Result

You know that cloud databases enable shared, centralized data storage accessible from many devices.

Understanding cloud databases is key because Firestore is a cloud database designed to keep data consistent across users.

2

Foundation

Basics of Firestore Data Structure

Concept: Learn how Firestore organizes data using documents and collections.

Firestore stores data in documents, which are like individual records, and groups these documents into collections, similar to folders. Each document holds key-value pairs, like a small dictionary of data.

Result

You can visualize Firestore data as nested folders (collections) containing files (documents) with information.

Knowing this structure helps you organize app data logically and query it efficiently.

3

Intermediate

Real-Time Data Synchronization

🤔Before reading on: do you think Firestore updates data instantly on all devices or only when the app refreshes? Commit to your answer.

Concept: Firestore automatically syncs data changes in real time across all connected devices.

When one user changes data, Firestore sends updates immediately to other users' devices without needing manual refresh. This keeps everyone seeing the latest information.

Result

Apps built with Firestore feel fast and responsive because data updates appear instantly everywhere.

Understanding real-time sync explains why Firestore is great for collaborative and live-update apps.

4

Intermediate

Offline Support and Data Persistence

🤔Before reading on: do you think Firestore apps stop working without internet or keep working offline? Commit to your answer.

Concept: Firestore caches data locally so apps can read and write data even without internet, syncing changes later.

If a user loses connection, Firestore lets the app keep working by saving changes locally. When the connection returns, Firestore syncs all updates to the cloud and other devices.

Result

Users experience smooth app behavior even with spotty internet.

Knowing offline support helps you build apps that work reliably anywhere, improving user experience.

5

Intermediate

Security with Firebase Rules

Concept: Firestore uses security rules to control who can read or write data.

You write rules that check user identity and data conditions before allowing access. This protects data from unauthorized users and mistakes.

Result

Your app data stays safe and private according to your rules.

Understanding security rules is essential to protect user data and comply with privacy requirements.

6

Advanced

Scalability and Performance Design

🤔Before reading on: do you think Firestore can handle millions of users easily or is it only for small apps? Commit to your answer.

Concept: Firestore is built to scale automatically, handling large amounts of data and users without manual setup.

Firestore distributes data across many servers and optimizes queries to keep performance high even as your app grows.

Result

Apps can grow from a few users to millions without changing database design.

Knowing Firestore's scalability helps you plan apps that grow smoothly without costly rewrites.

7

Expert

Trade-offs and Limitations of Firestore

🤔Before reading on: do you think Firestore is perfect for every app or has some trade-offs? Commit to your answer.

Concept: Firestore offers many benefits but also has limits like pricing based on operations and some query restrictions.

Firestore charges per read/write/delete operation, so inefficient queries can be costly. Also, complex queries require careful data modeling. Understanding these helps optimize cost and performance.

Result

You can design apps that use Firestore efficiently and avoid unexpected bills or slow queries.

Knowing Firestore's trade-offs is crucial for building cost-effective, high-performance apps in production.

Under the Hood

Firestore stores data in a distributed cloud system that replicates data across multiple servers for reliability. It uses a synchronization engine that listens for data changes and pushes updates to connected clients instantly. Offline support is achieved by caching data locally on devices and queuing writes until the network is available. Security rules are evaluated on the server before allowing data operations.

Why designed this way?

Firestore was designed to solve the challenges of building real-time, collaborative apps that scale globally. Traditional databases were either too slow for real-time sync or too complex to manage at scale. Google built Firestore to combine ease of use, real-time updates, offline support, and strong security in one managed service.

┌───────────────┐       ┌───────────────┐       ┌───────────────┐
│   Client A    │──────▶│               │       │   Client B    │
│ (Local cache) │       │   Firestore   │◀──────│ (Local cache) │
│               │◀──────│ (Cloud sync)  │──────▶│               │
└───────────────┘       └───────────────┘       └───────────────┘

Clients cache data locally and sync changes through Firestore's cloud servers, which replicate data and enforce security.

Myth Busters - 4 Common Misconceptions

Quick: Do you think Firestore automatically scales without any developer input? Commit to yes or no.

Common Belief: Firestore scales automatically and developers never need to think about performance.

Reality: While Firestore handles scaling of infrastructure, developers must design data and queries carefully to avoid performance bottlenecks and high costs.

Why it matters: Ignoring data modeling can lead to slow queries and expensive bills, hurting app usability and budget.

Quick: Do you think Firestore is just a simple key-value store? Commit to yes or no.

Common Belief: Firestore is just a basic key-value database without complex querying.

Reality: Firestore supports rich queries on documents and collections, including filtering, ordering, and compound queries, though with some limitations.

Why it matters: Underestimating Firestore's query capabilities can limit app features or lead to inefficient workarounds.

Quick: Do you think Firestore guarantees instant data sync even if the device is offline? Commit to yes or no.

Common Belief: Firestore syncs data instantly regardless of network status.

Reality: Firestore syncs instantly only when online; offline changes are cached locally and synced once the device reconnects.

Why it matters: Misunderstanding offline behavior can cause confusion about data consistency and app state.

Quick: Do you think Firestore security rules are optional and only for advanced apps? Commit to yes or no.

Common Belief: Security rules are optional and apps can rely on client code for data protection.

Reality: Security rules are mandatory to protect data on the server side; client code alone cannot secure data.

Why it matters: Skipping security rules risks exposing sensitive data and violating user privacy.

Expert Zone

1

Firestore's real-time listeners use efficient websockets but can increase costs if not managed carefully, especially with many active listeners.

2

Data modeling in Firestore often requires denormalization (duplicating data) to optimize queries, which differs from traditional relational databases.

3

Firestore's consistency model is strong for single documents but eventual for multi-document transactions, affecting how complex updates are designed.

When NOT to use

Firestore is not ideal for complex relational data with many joins or for heavy analytical queries; in such cases, traditional SQL databases or BigQuery are better alternatives.

Production Patterns

In production, Firestore is often combined with Firebase Authentication for secure user access, Cloud Functions for backend logic, and careful indexing to optimize query speed and cost.

Connections

Content Delivery Networks (CDNs)

Both Firestore and CDNs distribute data globally to improve speed and reliability.

Understanding how CDNs cache and deliver content helps grasp Firestore's local caching and global replication for fast data access.

Event-Driven Architecture

Firestore's real-time updates act like events triggering changes across systems.

Knowing event-driven systems clarifies how Firestore pushes data changes instantly to clients, enabling reactive app designs.

Collaborative Document Editing

Firestore supports real-time collaboration similar to how Google Docs syncs edits live.

Understanding collaborative editing explains why Firestore's sync and conflict resolution are critical for multi-user apps.

Common Pitfalls

#1 Ignoring data structure leads to inefficient queries and high costs.

Wrong approach:

Storing all data in one large collection and querying without indexes:
firestore.collection('allData').where('type', '==', 'user').get()

Correct approach:

Organizing data into multiple collections and creating indexes:
firestore.collection('users').where('active', '==', true).get()

Root cause:

Misunderstanding Firestore's query and indexing requirements causes poor performance and unexpected billing.

#2 Not implementing security rules exposes data to unauthorized access.

Wrong approach:

No security rules or overly permissive rules:
service cloud.firestore {
match /databases/{database}/documents {
match /{document=**} {
allow read, write: if true;
}
}
}

Correct approach:

Restrictive rules based on user authentication:
service cloud.firestore {
match /databases/{database}/documents {
match /users/{userId} {
allow read, write: if request.auth.uid == userId;
}
}
}

Root cause:

Assuming client-side code is enough for security leads to data leaks.

#3 Expecting offline changes to sync instantly without network.

Wrong approach:

Assuming data is updated on all devices immediately when offline.

Correct approach:

Designing app to handle local changes and sync on reconnect, informing users of offline status.

Root cause:

Misunderstanding offline behavior causes confusion about data consistency.

Key Takeaways

Firestore is a cloud database that syncs app data instantly across devices, enabling real-time collaboration.

Its document and collection structure makes data easy to organize and query efficiently.

Offline support ensures apps work smoothly even without internet, syncing changes later automatically.

Security rules are essential to protect data and must be carefully designed and tested.

While Firestore scales automatically, good data modeling and query design are crucial to control costs and maintain performance.

Practice

1. Why is Firestore considered Firebase's primary database?

easy

A. Because it only stores data temporarily

B. Because it requires manual scaling for large apps

C. Because it updates data in real time and works offline

D. Because it does not support security rules

Solution

1. Step 1: Understand Firestore's real-time update feature

   Firestore automatically updates data in real time, so apps stay current without manual refresh.

2. Step 2: Recognize offline support and automatic scaling

   Firestore works offline and scales automatically, making it easy to use and reliable.

3. Final Answer:

   Because it updates data in real time and works offline -> Option C

4. Quick Check:

   Real-time + offline = Firestore primary [OK]

Hint: Remember Firestore updates live and works offline [OK]

Common Mistakes:

• Thinking Firestore needs manual scaling
• Believing Firestore lacks security rules
• Confusing Firestore with temporary storage

2. Which of the following is the correct way to define a Firestore collection reference in Firebase SDK?

easy

A. const ref = firestore.collection('users');

B. const ref = firestore.getCollection('users');

C. const ref = firestore.users.collection();

D. const ref = firestore.collection.users();

Solution

1. Step 1: Recall Firestore collection syntax

   The correct method to get a collection reference is firestore.collection('collectionName').

2. Step 2: Check each option's syntax

   Only const ref = firestore.collection('users'); uses the correct method name and syntax.

3. Final Answer:

   const ref = firestore.collection('users'); -> Option A

4. Quick Check:

   Use .collection('name') to get collection [OK]

Hint: Use .collection('name') to get Firestore collections [OK]

Common Mistakes:

• Using getCollection instead of collection
• Accessing collection as a property
• Calling collection as a method on collection

3. Given this Firestore query code, what will be the output if the 'users' collection has documents with fields {name: 'Alice', age: 30} and {name: 'Bob', age: 25}?

const snapshot = await firestore.collection('users').where('age', '>', 26).get();
const names = snapshot.docs.map(doc => doc.data().name);
console.log(names);

medium

A. ['Alice']

B. ['Bob']

C. ['Alice', 'Bob']

D. []

Solution

1. Step 1: Analyze the query condition

   The query filters users where age is greater than 26.

2. Step 2: Check which users match the condition

   Alice is 30 (matches), Bob is 25 (does not match).

3. Final Answer:

   ['Alice'] -> Option A

4. Quick Check:

   Age > 26 returns Alice only [OK]

Hint: Filter by age > 26 returns only Alice [OK]

Common Mistakes:

• Including Bob who is 25
• Returning empty array by mistake
• Returning both users ignoring filter

4. Which of the following correctly describes this Firestore security rule snippet?

service cloud.firestore {
  match /databases/{database}/documents {
    match /users/{userId} {
      allow read, write: if request.auth.uid == userId;
    }
  }
}

medium

A. It does not allow any access to users

B. It allows read and write only if user is authenticated and matches userId

C. It allows access without authentication

D. It has syntax errors in the match statements

Solution

1. Step 1: Understand the rule condition

   The rule allows read and write only if the authenticated user's ID matches the document's userId.

2. Step 2: Check for errors or incorrect logic

   The syntax is correct and the logic restricts access properly.

3. Final Answer:

   It allows read and write only if user is authenticated and matches userId -> Option B

4. Quick Check:

   Auth check with userId match = correct rule [OK]

Hint: Check if auth uid matches userId for access [OK]

Common Mistakes:

• Thinking it allows access without auth
• Assuming syntax errors exist
• Believing it denies all access

5. You want to build a chat app that works offline and syncs messages automatically when online. Why is Firestore the best choice for this?

hard

A. Because Firestore only stores data temporarily in memory

B. Because Firestore requires manual syncing and no offline support

C. Because Firestore does not support real-time updates

D. Because Firestore supports offline data persistence and real-time syncing

Solution

1. Step 1: Identify offline support in Firestore

   Firestore caches data locally, so apps work offline without errors.

2. Step 2: Recognize real-time syncing feature

   When online, Firestore syncs changes automatically to keep data updated.

3. Step 3: Compare with other options

   Options A, B, and D contradict Firestore's key features.

4. Final Answer:

   Because Firestore supports offline data persistence and real-time syncing -> Option D

5. Quick Check:

   Offline + real-time sync = Firestore best for chat [OK]

Hint: Offline persistence + real-time sync = Firestore wins [OK]

Common Mistakes:

• Thinking Firestore needs manual sync
• Believing Firestore lacks offline support
• Confusing Firestore with temporary storage