Fan-out writes pattern in Firebase - Step-by-Step Execution

Process Flow - Fan-out writes pattern

Client sends data to write

↓

Server receives data

↓

Write data to main location

↓

Write same data to multiple locations

↓

Confirm all writes succeed

↓

Return success

The fan-out writes pattern copies data to multiple places in the database at once to keep data consistent and improve read speed.

Execution Sample

Firebase

const updates = {};
updates['/posts/post1'] = postData;
updates['/user-posts/user1/post1'] = postData;
return firebase.database().ref().update(updates);

This code writes the same post data to two places in the database at once using a single update call.

Process Table

Step	Action	Data Location	Data Written	Result
1	Prepare updates object	N/A	{'/posts/post1': postData, '/user-posts/user1/post1': postData}	Ready to write
2	Call update() with updates	Root	Multiple paths	Start atomic write
3	Write to /posts/post1	/posts/post1	postData	Success
4	Write to /user-posts/user1/post1	/user-posts/user1/post1	postData	Success
5	All writes complete	N/A	N/A	Return success to client

💡 All writes succeed, update() completes atomically

Status Tracker

Variable	Start	After Step 1	After Step 2	After Step 5
updates	{}	{'/posts/post1': postData, '/user-posts/user1/post1': postData}	Same	Same

Key Moments - 3 Insights

Why do we write the same data to multiple locations?

Writing to multiple locations keeps data consistent and allows faster reads from different parts of the app, as shown in steps 3 and 4 of the execution_table.

What happens if one write fails during update()?

The update() call is atomic, so if any write fails, none are applied. This ensures data consistency, as implied in the exit_note.

Why use a single update() call instead of multiple separate writes?

A single update() call ensures all writes happen together atomically, avoiding partial updates and keeping data consistent, as shown in steps 2 to 5.

Visual Quiz - 3 Questions

Look at the execution_table, what data is written at step 3?

A postData to /posts/post1

B postData to /user-posts/user1/post1

C updates object to root

D No data written

💡 Hint

Check the 'Data Location' and 'Data Written' columns in step 3 of execution_table

At which step does the client receive confirmation that all writes succeeded?

A Step 2

B Step 5

C Step 4

D Step 1

💡 Hint

Look at the 'Result' column for when the update completes successfully

If the update() call was split into two separate writes, what risk increases?

A No risk, same behavior

B Writes become atomic automatically

C Data might be partially written causing inconsistency

D Writes happen faster

💡 Hint

Refer to key_moments about atomicity and partial writes

Concept Snapshot

Fan-out writes pattern:
- Write same data to multiple database paths
- Use a single atomic update() call
- Keeps data consistent across locations
- Improves read performance
- Avoids partial updates

Full Transcript

The fan-out writes pattern in Firebase means writing the same data to multiple places in the database at once. This is done by creating an updates object with all target paths and data, then calling update() once. This ensures all writes happen together atomically, so either all succeed or none do. This keeps data consistent and allows faster reads from different parts of the app. The execution steps show preparing the updates, calling update(), writing to each location, and finally confirming success. Key points include why multiple writes are needed, atomicity of update(), and risks of separate writes. This pattern is important for keeping data synchronized and reliable.