Realtime Database vs Firestore decision in Firebase - Performance Comparison

Time Complexity: Realtime Database vs Firestore decision

O(n)

Understanding Time Complexity

When choosing between Firebase Realtime Database and Firestore, it's important to understand how their operation costs grow as your data or users increase.

We want to see how the number of database calls changes when reading or writing data.

Scenario Under Consideration

Analyze the time complexity of reading a list of user messages from each database.

// Realtime Database
const messagesRef = firebase.database().ref('messages');
messagesRef.once('value').then(snapshot => {
  const messages = snapshot.val();
  // process messages
});

// Firestore
const messagesCollection = firebase.firestore().collection('messages');
messagesCollection.get().then(querySnapshot => {
  querySnapshot.forEach(doc => {
    const message = doc.data();
    // process message
  });
});
    

This code reads all messages once from each database type to process them.

Identify Repeating Operations

Look at what happens repeatedly when reading data.

• Primary operation: Reading each message record from the database.
• How many times: Once per message in the list.

How Execution Grows With Input

As the number of messages grows, the number of read operations grows too.

Input Size (n)	Approx. Api Calls/Operations
10	1 read
100	1 read
1000	1 read

Pattern observation: The number of operations grows directly with the number of messages.

Final Time Complexity

Time Complexity: O(n)

This means the time to read all messages grows linearly with how many messages there are.

Common Mistake

[X] Wrong: "Reading a large list from Firestore or Realtime Database is always a single operation regardless of size."

[OK] Correct: Each message is a separate read operation, so more messages mean more reads and longer time.

Interview Connect

Understanding how database reads scale helps you design apps that stay fast as they grow. This skill shows you can think about real-world app performance.

Self-Check

"What if we used Firestore queries to limit results instead of reading all messages? How would the time complexity change?"

Practice

1. Which Firebase database is best suited for simple real-time syncing of data as a JSON tree?

easy

A. Realtime Database

B. Firestore

C. Cloud Storage

D. Firebase Hosting

Solution

1. Step 1: Understand data structure of Realtime Database

   Realtime Database stores data as a JSON tree, which is simple and fast for syncing.

2. Step 2: Compare with Firestore

   Firestore uses collections and documents, better for complex queries but not just simple JSON tree syncing.

3. Final Answer:

   Realtime Database -> Option A

4. Quick Check:

   Simple JSON tree sync = Realtime Database [OK]

Hint: Simple JSON tree and fast sync? Choose Realtime Database [OK]

Common Mistakes:

• Confusing Firestore with Realtime Database
• Choosing Cloud Storage for database needs
• Thinking Firebase Hosting stores data

2. Which syntax correctly references a document in Firestore?

easy

A. db.store('users').document('user1')

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

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

D. db.ref('users/user1')

Solution

1. Step 1: Recall Firestore document reference syntax

   Firestore uses collection().doc() to reference documents.

2. Step 2: Identify incorrect options

   db.ref() is Realtime Database syntax; db.get() and db.store() are invalid here.

3. Final Answer:

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

4. Quick Check:

   Firestore document ref = collection().doc() [OK]

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

Common Mistakes:

• Using Realtime Database syntax for Firestore
• Mixing method names like get() or store()
• Confusing document and collection references

3. Given this Firestore query code, what will be the output if the 'users' collection has documents with ages 20, 25, and 30?

db.collection('users').where('age', '>', 22).get().then(snapshot => {
  let result = [];
  snapshot.forEach(doc => result.push(doc.data().age));
  console.log(result);
});

medium

A. [25, 30]

B. [20, 25, 30]

C. [22, 25]

D. []

Solution

1. Step 1: Understand the query condition

   The query filters users where age is greater than 22, so ages 25 and 30 qualify.

2. Step 2: Determine the output array

   The code collects ages from matching documents, so output is [25, 30].

3. Final Answer:

   [25, 30] -> Option A

4. Quick Check:

   age > 22 = [25, 30] [OK]

Hint: Filter > 22 excludes 20, includes 25 and 30 [OK]

Common Mistakes:

• Including 20 which is not > 22
• Confusing >= with > operator
• Assuming empty result without checking data

4. You wrote this Realtime Database code but it throws an error:

firebase.database().collection('users').doc('user1').get()

What is the main issue?

medium

A. Missing authentication before accessing database

B. The get() method is asynchronous and needs await

C. Realtime Database does not have collection() or doc() methods

D. The database URL is not specified

Solution

1. Step 1: Identify API mismatch

   Realtime Database uses ref() instead of collection() and doc(), which are Firestore methods.

2. Step 2: Confirm correct method usage

   Using collection() and doc() on Realtime Database causes error because those methods don't exist there.

3. Final Answer:

   Realtime Database does not have collection() or doc() methods -> Option C

4. Quick Check:

   Realtime DB uses ref(), not collection()/doc() [OK]

Hint: Realtime DB uses ref(), not collection() or doc() [OK]

Common Mistakes:

• Assuming get() needs await causes confusion
• Blaming authentication without checking API
• Thinking database URL causes this syntax error

5. You need to build a chat app that requires fast real-time updates and simple data structure. Which Firebase database should you choose and why?

hard

A. Firestore, because it supports complex queries and offline caching

B. Firestore, because it scales better for large datasets

C. Realtime Database, because it stores data in collections and documents

D. Realtime Database, because it syncs data instantly as a JSON tree

Solution

1. Step 1: Analyze app requirements

   The chat app needs fast real-time updates and a simple data structure.

2. Step 2: Match requirements to database features

   Realtime Database syncs data instantly as a JSON tree, ideal for simple real-time apps.

3. Step 3: Eliminate incorrect options

   Firestore supports complex queries and scales well but is more complex; Realtime Database does not use collections/documents.

4. Final Answer:

   Realtime Database, because it syncs data instantly as a JSON tree -> Option D

5. Quick Check:

   Simple real-time chat = Realtime Database [OK]

Hint: Fast real-time + simple data? Pick Realtime Database [OK]

Common Mistakes:

• Choosing Firestore for simple real-time needs
• Confusing data structure of Realtime Database
• Assuming Realtime Database uses collections/documents