Transaction basics in Firebase - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ service_behavior

intermediate

What is the output of this Firebase transaction code?

Consider this Firebase transaction on a document with initial field count: 5. What will be the final value of count after this transaction completes successfully?

Firebase

const docRef = firestore.collection('counters').doc('counter1');

await firestore.runTransaction(async (transaction) => {
  const doc = await transaction.get(docRef);
  const newCount = (doc.data()?.count ?? 0) + 3;
  transaction.update(docRef, { count: newCount });
});

A 0

B 3

C 5

D 8

💡 Hint

Think about how the transaction reads the current value and adds 3.

The transaction reads the current count value (5), adds 3, and updates it to 8.

🧠 Conceptual

intermediate

Which statement about Firebase transactions is true?

Choose the correct statement about Firebase transactions.

A Transactions can only update one document at a time.

B Transactions automatically retry if data changes during the transaction.

C Transactions do not guarantee atomicity across multiple documents.

D Transactions can only read data but cannot write updates.

💡 Hint

Think about how Firebase handles concurrent updates inside transactions.

Firebase transactions automatically retry if the data they read changes before commit, ensuring atomicity.

❓ Configuration

advanced

What error occurs with this Firebase transaction code?

What error will this Firebase transaction code raise when executed?

Firebase

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

await firestore.runTransaction(async (transaction) => {
  transaction.update(docRef, { score: 10 });
  const doc = await transaction.get(docRef);
  console.log(doc.data());
});

A TransactionError: Cannot update before reading document

B SyntaxError: Missing await before transaction.update

C No error, transaction runs successfully

D TypeError: transaction.update is not a function

💡 Hint

Check the order of operations allowed in Firebase transactions.

Firebase transactions allow updates before reads; this code runs without error.

❓ security

advanced

Which Firebase security rule prevents unauthorized transaction writes?

Given a Firestore collection orders, which security rule correctly prevents users from updating orders they do not own, even inside transactions?

A allow update: if request.auth.uid == resource.data.ownerId;

B allow update: if request.auth.uid != resource.data.ownerId;

C allow update: if request.auth.token.admin == true;

D allow update: if request.time < timestamp.date(2025, 1, 1);

💡 Hint

Think about how to restrict updates to only the owner of the document.

Rule A allows updates only if the authenticated user ID matches the document's owner ID, securing transaction writes.

❓ Architecture

expert

What is the best explanation for why Firebase transactions retry automatically?

Firebase transactions retry automatically when data changes during the transaction. Why is this behavior important in distributed systems?

A To ensure eventual consistency by resolving conflicts caused by concurrent updates.

B To reduce network traffic by batching multiple writes into one request.

C To prevent any writes from happening if the user is offline.

D To guarantee that transactions always complete within a fixed time limit.

💡 Hint

Consider how multiple users might update the same data at the same time.

Automatic retries help maintain data consistency by handling conflicts from concurrent updates in distributed environments.