Server timestamps in Firebase - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ service_behavior

intermediate

Understanding Firebase Server Timestamps Behavior

When you set a field in a Firestore document to firebase.firestore.FieldValue.serverTimestamp(), what will be the value of that field immediately after the write operation completes on the client?

A The exact server time at the moment the write was processed by Firestore.

B A placeholder value that will be replaced asynchronously with the server timestamp once confirmed.

C The client's local time at the moment the write was initiated.

D Null, because the server timestamp is not available on the client.

💡 Hint

Think about how Firestore handles latency and synchronization between client and server.

When you write serverTimestamp(), Firestore sets a placeholder on the client. This placeholder is replaced asynchronously with the actual server time once the server confirms the write. This allows the client to show a temporary value while waiting for the server.

❓ Configuration

intermediate

Using Server Timestamps in Firestore Document Updates

You want to update a Firestore document's lastModified field to the current server time. Which of the following update commands correctly sets the lastModified field to the server timestamp?

Firebase

const docRef = firestore.collection('users').doc('user123');

// Which update command is correct?

A docRef.update({ lastModified: firebase.firestore.FieldValue.serverTimestamp() });

B docRef.update({ lastModified: new Date() });

C docRef.set({ lastModified: firebase.firestore.FieldValue.serverTimestamp() });

D docRef.update({ lastModified: firebase.firestore.Timestamp.now() });

💡 Hint

Consider which method updates only the specified fields and which value represents the server timestamp.

Using update() with firebase.firestore.FieldValue.serverTimestamp() sets the field to the server time. set() replaces the whole document unless merge is used. new Date() uses client time, and Timestamp.now() is client-side timestamp, not server.

❓ Architecture

advanced

Designing a Firestore Schema with Server Timestamps for Audit Logs

You are designing an audit log system in Firestore that records user actions with timestamps. You want to ensure timestamps are consistent and trustworthy. Which architecture choice best achieves this?

A Store timestamps as strings formatted on the client side for readability.

B Use client-generated timestamps with <code>new Date()</code> and trust client clocks.

C Use <code>firebase.firestore.FieldValue.serverTimestamp()</code> for all timestamp fields to ensure server time consistency.

D Use a Cloud Function to add timestamps after writes, ignoring client timestamps.

💡 Hint

Think about trustworthiness and consistency of timestamps in distributed systems.

Using serverTimestamp() ensures all timestamps come from the server, avoiding client clock skew or manipulation. This is critical for audit logs. Cloud Functions can add timestamps but add complexity and latency. Client timestamps are unreliable.

❓ security

advanced

Securing Firestore Writes with Server Timestamps

You want to prevent clients from spoofing timestamps in Firestore writes. Which Firestore security rule best enforces that the createdAt field is set only to the server timestamp?

A allow write: if request.resource.data.createdAt == request.time;

B allow write: if request.resource.data.createdAt == request.resource.data.createdAt;

C allow write: if request.resource.data.createdAt == request.auth.token.timestamp;

D allow write: if request.resource.data.createdAt != null;

💡 Hint

Consider how Firestore security rules access server time and request data.

In Firestore security rules, request.time is the server timestamp at the time of the request. Comparing createdAt to request.time ensures the client cannot spoof the timestamp. Other options either compare to client data or are always true.

✅ Best Practice

expert

Handling Missing Server Timestamps in Offline Firestore Clients

When a Firestore client is offline and writes a document with a serverTimestamp() field, what is the best practice to handle the timestamp field in your app UI before the client reconnects?

A Set the timestamp field to null and never update it.

B Show the client's local time as the timestamp immediately after the write.

C Hide the timestamp field completely until the client reconnects.

D Display a loading indicator or placeholder until the server timestamp is available.

💡 Hint

Think about user experience and data consistency when server data is delayed.

Since server timestamps are placeholders offline, showing a loading indicator or placeholder informs users the timestamp is pending. Showing client time risks confusion. Hiding or nulling loses context or misleads users.

Practice

1. What is the main purpose of using firebase.firestore.FieldValue.serverTimestamp() in Firestore?

easy

A. To get the current time from the user's device

B. To store the exact time from the server when the data is written

C. To create a random timestamp for testing

D. To convert a timestamp to a readable string

Solution

1. Step 1: Understand server timestamp usage

   The method serverTimestamp() sets the field to the current time according to the server, not the client device.

2. Step 2: Compare with other options

   Options B, C, and D do not describe server-based time storage. Only To store the exact time from the server when the data is written correctly describes storing server time when data is written.

3. Final Answer:

   To store the exact time from the server when the data is written -> Option B

4. Quick Check:

   Server timestamp = accurate server time [OK]

Hint: Server timestamp always uses server time, not client time [OK]

Common Mistakes:

• Thinking it uses client device time
• Confusing with formatting timestamps
• Assuming it generates random times

2. Which of the following is the correct syntax to set a Firestore document field to the server timestamp?

easy

A. docRef.set({ createdAt: firebase.firestore.FieldValue.serverTimestamp() })

B. docRef.set({ createdAt: new Date() })

C. docRef.set({ createdAt: Date.now() })

D. docRef.set({ createdAt: firebase.firestore.Timestamp.now() })

Solution

1. Step 1: Identify correct method for server timestamp

   The correct method to set a server timestamp in Firestore is firebase.firestore.FieldValue.serverTimestamp().

2. Step 2: Check other options for correctness

   docRef.set({ createdAt: new Date() }) uses client time with new Date(). docRef.set({ createdAt: Date.now() }) uses client time with Date.now(). docRef.set({ createdAt: firebase.firestore.Timestamp.now() }) uses current timestamp but from client side. Only docRef.set({ createdAt: firebase.firestore.FieldValue.serverTimestamp() }) uses the server timestamp method.

3. Final Answer:

   docRef.set({ createdAt: firebase.firestore.FieldValue.serverTimestamp() }) -> Option A

4. Quick Check:

   Correct syntax = docRef.set({ createdAt: firebase.firestore.FieldValue.serverTimestamp() }) [OK]

Hint: Use FieldValue.serverTimestamp() to get server time [OK]

Common Mistakes:

• Using client-side Date or Timestamp instead
• Missing firebase.firestore prefix
• Using parentheses incorrectly

3. Consider this Firestore update code:

docRef.update({ lastModified: firebase.firestore.FieldValue.serverTimestamp() });

What will be the value of lastModified immediately after this update on the client side?

medium

A. The client device's current time

B. The exact server timestamp value

C. null until the server confirms the update

D. An error because serverTimestamp() cannot be used in update

Solution

1. Step 1: Understand serverTimestamp behavior on client

   When using serverTimestamp(), Firestore sets the field to null locally until the server responds with the actual timestamp.

2. Step 2: Evaluate options based on this behavior

   The exact server timestamp value is incorrect because the client does not have the exact server time immediately. The client device's current time is wrong because client time is not used. An error because serverTimestamp() cannot be used in update is wrong because serverTimestamp() can be used in update. null until the server confirms the update correctly states the field is null initially.

3. Final Answer:

   null until the server confirms the update -> Option C

4. Quick Check:

   Local value before server response = null [OK]

Hint: Local timestamp is null until server confirms [OK]

Common Mistakes:

• Expecting immediate server time on client
• Confusing update with set behavior
• Assuming client time is used

4. You wrote this Firestore code but get an error:

docRef.set({ createdAt: firebase.firestore.serverTimestamp() });

What is the likely cause of the error?

medium

A. The document reference docRef is undefined

B. Using set instead of update

C. Server timestamps cannot be used in set calls

D. Missing FieldValue in the method call

Solution

1. Step 1: Check the method call syntax

   The correct method to get a server timestamp is firebase.firestore.FieldValue.serverTimestamp(). The code misses FieldValue.

2. Step 2: Verify other options

   Using set instead of update is incorrect because set supports server timestamps. Server timestamps cannot be used in set calls is false for the same reason. The document reference docRef is undefined could cause an error but the question implies a syntax mistake.

3. Final Answer:

   Missing FieldValue in the method call -> Option D

4. Quick Check:

   Correct method includes FieldValue [OK]

Hint: Always include FieldValue before serverTimestamp() [OK]

Common Mistakes:

• Omitting FieldValue in method call
• Confusing set and update restrictions
• Assuming serverTimestamp is a direct method of firestore

5. You want to store a user's last login time using server timestamps but only update it if the new login time is later than the existing one. Which Firestore approach correctly applies this logic?

hard

A. Use a Firestore transaction to read current timestamp and update with serverTimestamp() if newer

B. Read the current timestamp, compare client time, then conditionally update with serverTimestamp()

C. Use serverTimestamp() directly in update() without checks

D. Set the timestamp field with client time and rely on serverTimestamp() fallback

Solution

1. Step 1: Understand conditional update needs

   To update only if the new login time is later, you must read the current value and compare before writing.

2. Step 2: Identify Firestore feature for atomic read-write

   Firestore transactions allow reading a document and conditionally updating it atomically, ensuring no race conditions.

3. Step 3: Evaluate options

   Use serverTimestamp() directly in update() without checks ignores condition. Read the current timestamp, compare client time, then conditionally update with serverTimestamp() uses client time which is unreliable. Set the timestamp field with client time and rely on serverTimestamp() fallback mixes client and server times incorrectly. Use a Firestore transaction to read current timestamp and update with serverTimestamp() if newer correctly uses a transaction with serverTimestamp.

4. Final Answer:

   Use a Firestore transaction to read current timestamp and update with serverTimestamp() if newer -> Option A

5. Quick Check:

   Conditional update needs transaction [OK]

Hint: Use transactions for conditional server timestamp updates [OK]

Common Mistakes:

• Relying on client time for comparisons
• Not using transactions for atomic checks
• Updating without checking existing timestamp