Why Realtime Database differs from Firestore in Firebase - Visual Breakdown

Process Flow - Why Realtime Database differs from Firestore

Start: Choose Database

↓

Realtime Database

↓

Data stored as JSON tree

↓

Syncs data in real-time

↓

Simple queries, limited scaling

↓

Firestore

↓

Data stored as collections & documents

↓

Syncs data in real-time + offline

↓

Advanced queries, better scaling

This flow shows the main differences: Realtime Database stores data as one big JSON tree with simple queries, while Firestore uses collections and documents with advanced queries and better scaling.

Execution Sample

Firebase

Realtime DB: data = {users: {user1: {name: 'Ana'}}}
Firestore: users collection -> user1 document -> {name: 'Ana'}

Shows how data is structured differently in Realtime Database (one JSON tree) vs Firestore (collections and documents).

Process Table

Step	Database Type	Data Structure	Sync Behavior	Query Capability
1	Realtime Database	Single JSON tree	Real-time sync of entire tree or paths	Simple queries, limited filtering
2	Firestore	Collections and documents	Real-time sync with offline support	Advanced queries with filters and indexes
3	Realtime Database	Flat or nested JSON	Syncs all connected clients instantly	No complex joins or compound queries
4	Firestore	Hierarchical collections	Syncs clients with efficient updates	Supports compound queries and pagination
5	Realtime Database	Data stored as one large JSON blob	Less scalable for large datasets	Limited scalability
6	Firestore	Data split into documents	Designed for large scale apps	Better scalability and performance
7	End	-	-	-

💡 Comparison ends after showing key differences in data structure, sync, and query capabilities.

Status Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
Data Structure	undefined	JSON tree	Collections & documents	Collections & documents	Collections & documents
Sync Behavior	undefined	Real-time sync	Real-time + offline	Real-time + offline	Real-time + offline
Query Capability	undefined	Simple queries	Advanced queries	Advanced queries	Advanced queries

Key Moments - 3 Insights

Why does Realtime Database use a JSON tree instead of collections and documents?

Realtime Database was designed first and uses a single JSON tree for simplicity, which limits complex queries as shown in execution_table rows 1 and 3.

How does Firestore support more advanced queries than Realtime Database?

Firestore stores data in collections and documents with indexes, enabling compound queries and pagination, as seen in execution_table rows 2 and 4.

Why is Firestore better for large scale apps compared to Realtime Database?

Firestore's data model and sync mechanism are optimized for scalability and performance, unlike Realtime Database's large JSON blob, as explained in rows 5 and 6.

Visual Quiz - 3 Questions

Look at the execution_table, what data structure does Realtime Database use at step 1?

A Collections and documents

B Single JSON tree

C Relational tables

D Key-value pairs

💡 Hint

Check the 'Data Structure' column in execution_table row 1.

At which step does Firestore show support for offline sync?

A Step 2

B Step 3

C Step 1

D Step 5

💡 Hint

Look at the 'Sync Behavior' column for Firestore in execution_table row 2.

If Realtime Database used collections and documents, how would the 'Query Capability' change in the table?

A It would not change

B It would remain simple queries

C It would support advanced queries

D It would support relational joins

💡 Hint

Refer to Firestore's query capabilities in execution_table rows 2 and 4.

Concept Snapshot

Realtime Database stores data as one big JSON tree.
It syncs data in real-time but supports only simple queries.
Firestore stores data in collections and documents.
It supports real-time sync with offline and advanced queries.
Firestore scales better for large apps.

Full Transcript

This visual execution compares Firebase Realtime Database and Firestore. Realtime Database uses a single JSON tree to store data, syncing all connected clients instantly with simple queries. Firestore organizes data into collections and documents, enabling advanced queries, offline support, and better scalability. The execution table shows step-by-step differences in data structure, sync behavior, and query capabilities. Key moments clarify why Realtime Database is simpler but less scalable, and why Firestore is designed for complex, large-scale apps. The quiz tests understanding of these differences by referencing the execution table and variable tracker.

Practice

1. What is a key difference between Firebase Realtime Database and Firestore in how they store data?

easy

A. Realtime Database stores data as one large JSON tree, while Firestore uses collections and documents.

B. Realtime Database uses tables and rows, Firestore uses JSON files.

C. Realtime Database stores data in XML format, Firestore uses CSV files.

D. Realtime Database uses collections and documents, Firestore uses one big JSON tree.

Solution

1. Step 1: Understand Realtime Database data structure

   Realtime Database organizes data as a single large JSON tree, making it simple but less structured.

2. Step 2: Understand Firestore data structure

   Firestore organizes data into collections and documents, allowing more structure and flexibility.

3. Final Answer:

   Realtime Database stores data as one large JSON tree, while Firestore uses collections and documents. -> Option A

4. Quick Check:

   Data structure difference = Realtime Database stores data as one large JSON tree, while Firestore uses collections and documents. [OK]

Hint: Remember: JSON tree vs collections-documents [OK]

Common Mistakes:

• Confusing Firestore's collections with Realtime Database's JSON tree
• Thinking both use the same data structure
• Mixing up file formats like XML or CSV

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

easy

A. db.ref('users/user123')

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

C. db.table('users').row('user123')

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

Solution

1. Step 1: Identify Firestore syntax

   Firestore uses collections and documents accessed by db.collection('name').doc('id').

2. Step 2: Compare options

   db.collection('users').doc('user123') matches Firestore syntax; db.ref('users/user123') is Realtime Database style; Options C and D are invalid.

3. Final Answer:

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

4. Quick Check:

   Firestore document reference = db.collection('users').doc('user123') [OK]

Hint: Firestore uses collection().doc() syntax [OK]

Common Mistakes:

• Using Realtime Database syntax for Firestore
• Confusing doc() with ref()
• Trying to use SQL-like table and row methods

3. Consider this Firestore query code:

const users = await db.collection('users').where('age', '>', 18).get();
console.log(users.docs.length);

What will this code output compared to a similar Realtime Database query?

medium

A. Always zero because Firestore cannot filter by age.

B. Syntax error because Firestore does not support where queries.

C. Number of users older than 18, Firestore supports this query directly.

D. Number of users older than 18, but Realtime Database cannot do this query.

Solution

1. Step 1: Understand Firestore query capabilities

   Firestore supports advanced queries like filtering with where clauses.

2. Step 2: Compare with Realtime Database

   Realtime Database has limited querying and cannot filter by fields easily.

3. Final Answer:

   Number of users older than 18, Firestore supports this query directly. -> Option C

4. Quick Check:

   Firestore advanced queries = Number of users older than 18, Firestore supports this query directly. [OK]

Hint: Firestore supports where queries; Realtime Database limited [OK]

Common Mistakes:

• Thinking Firestore cannot filter data
• Assuming Realtime Database supports complex queries
• Confusing query syntax between databases

4. You wrote this Realtime Database code:

const ref = db.ref('users').orderByChild('age').equalTo(25);
ref.on('value', snapshot => { console.log(snapshot.val()); });

But it returns null even though users with age 25 exist. What is the likely issue?

medium

A. Realtime Database cannot query by child properties.

B. Firestore syntax was used instead of Realtime Database syntax.

C. The database path 'users' does not exist.

D. The query is invalid; Realtime Database requires indexes for orderByChild queries.

Solution

1. Step 1: Check Realtime Database query requirements

   Realtime Database needs proper indexing for orderByChild queries to work.

2. Step 2: Identify cause of null result

   Without indexes, the query returns null even if data exists.

3. Final Answer:

   The query is invalid; Realtime Database requires indexes for orderByChild queries. -> Option D

4. Quick Check:

   Missing index causes null result = The query is invalid; Realtime Database requires indexes for orderByChild queries. [OK]

Hint: Realtime DB needs indexes for orderByChild queries [OK]

Common Mistakes:

• Confusing Firestore and Realtime Database syntax
• Assuming data path is missing without checking
• Believing Realtime Database cannot query child properties

5. You want to build a chat app with many users and complex queries on messages. Which Firebase database should you choose and why?

hard

A. Use Firestore because it supports complex queries and scales well.

B. Use Realtime Database because it scales better for complex queries.

C. Use Realtime Database because it uses collections and documents.

D. Use Firestore because it stores data as one big JSON tree.

Solution

1. Step 1: Analyze app requirements

   A chat app with many users and complex queries needs good scaling and query support.

2. Step 2: Compare database features

   Firestore supports complex queries and scales better than Realtime Database for large apps.

3. Final Answer:

   Use Firestore because it supports complex queries and scales well. -> Option A

4. Quick Check:

   Complex queries + scaling = Firestore [OK]

Hint: Choose Firestore for complex queries and scaling [OK]

Common Mistakes:

• Choosing Realtime Database for complex queries
• Confusing data structure descriptions
• Ignoring scaling needs for large apps