How to Create a Secure Data Backup System in FlutterFlow

Create a backup_jobs collection with fields: userId (String), status (String: pending, processing, completed, failed), type (String: export, restore, delete), downloadUrl (String, set when complete), fileSize (int, bytes), error (String, if failed), createdAt (Timestamp), completedAt (Timestamp). When a user initiates an export, a backup_jobs document is created with status 'pending'. The Cloud Function picks it up, processes it, and updates the status. The FlutterFlow page polls this document to show progress and the download link when ready.

Deploy a Cloud Function called exportUserData triggered by Firestore onCreate on the backup_jobs collection (filtered to type 'export'). The function updates status to 'processing', then queries all collections containing user data: the user profile document, all posts where authorId equals the userId, all orders where userId matches, and any other user-scoped collections. It compiles everything into a JSON object, converts it to a Buffer, uploads the buffer to Firebase Storage at path backups/{userId}/{timestamp}.json, generates a signed download URL (24-hour expiry), and updates the backup_jobs document with status 'completed', the downloadUrl, and fileSize.

1// Cloud Function: exportUserData
2const functions = require('firebase-functions');
3const admin = require('firebase-admin');
4admin.initializeApp();
5
6exports.exportUserData = functions.firestore
7  .document('backup_jobs/{jobId}')
8  .onCreate(async (snap, context) => {
9    const job = snap.data();
10    if (job.type !== 'export') return;
11    
12    const jobRef = snap.ref;
13    await jobRef.update({ status: 'processing' });
14    
15    try {
16      const uid = job.userId;
17      const db = admin.firestore();
18      
19      // Gather all user data
20      const userData = {};
21      userData.profile = (await db.collection('users').doc(uid).get()).data();
22      userData.posts = (await db.collection('posts')
23        .where('authorId', '==', uid).get())
24        .docs.map(d => d.data());
25      userData.orders = (await db.collection('orders')
26        .where('userId', '==', uid).get())
27        .docs.map(d => d.data());
28      
29      // Upload to Storage
30      const bucket = admin.storage().bucket();
31      const filename = `backups/${uid}/${Date.now()}.json`;
32      const file = bucket.file(filename);
33      const buffer = Buffer.from(JSON.stringify(userData, null, 2));
34      await file.save(buffer, { contentType: 'application/json' });
35      
36      const [url] = await file.getSignedUrl({
37        action: 'read',
38        expires: Date.now() + 24 * 60 * 60 * 1000,
39      });
40      
41      await jobRef.update({
42        status: 'completed',
43        downloadUrl: url,
44        fileSize: buffer.length,
45        completedAt: admin.firestore.FieldValue.serverTimestamp(),
46      });
47    } catch (err) {
48      await jobRef.update({ status: 'failed', error: err.message });
49    }
50  });

On the Settings page, add a section called Data Management. Add a button labeled Export My Data. On tap, create a backup_jobs document with userId set to the current user, type 'export', and status 'pending'. Then display a progress section: query the backup_jobs document and show the current status with appropriate icons (clock for pending, spinner for processing, checkmark for completed, X for failed). When status is 'completed', show a Download button that launches the downloadUrl. Use a periodic Backend Query refresh (or FlutterFlow's real-time query with Single Time Query OFF) to automatically update the status display.

Deploy a Cloud Function called restoreUserData that receives a backup file URL and userId. The function downloads the JSON file from Storage, parses it, and re-creates the Firestore documents. For each collection (profile, posts, orders), it uses batch writes to create the documents. The function handles conflicts: if a document with the same ID already exists, it either merges or skips based on a parameter. Track the restore job in backup_jobs with type 'restore'. This is useful for recovering accidentally deleted data or migrating between accounts.

Add a Delete All My Data button with a prominent red style and a two-step confirmation: first a dialog explaining what will be deleted, then a TextField requiring the user to type 'DELETE' to confirm. On confirmation, create a backup_jobs document with type 'delete'. The Cloud Function deletes all user documents across every collection (posts, orders, comments, etc.), deletes all Storage files under the user's path, and finally deletes the Firebase Auth account using admin.auth().deleteUser(uid). After deletion, the app signs the user out and navigates to a goodbye confirmation page.

Below the Export button, add a ListView querying backup_jobs where userId equals the current user, ordered by createdAt descending. Each item shows: the job type (export/restore/delete), status badge (color-coded), creation date, file size (for exports), and a re-download link if the URL has not expired. Add a note that download links expire after 24 hours. For expired links, show a Re-export button that creates a new backup job. This gives users a complete history of their data management actions.