How to Track User Behavior in Your FlutterFlow App

Open the Firebase Console and navigate to your project's Firestore Database. Create a new collection named 'analytics_events'. Each document in this collection represents one user action and should contain: event (String — the event name like 'screen_view' or 'button_tap'), screen (String — current page name), uid (String — Firebase Auth user ID), sessionId (String — random ID per app session), timestamp (Timestamp — Firestore server timestamp), properties (Map — flexible key-value data specific to the event). You do not need to create the collection manually if it does not exist — Firestore creates collections automatically on the first write. However, setting up the collection now lets you configure Firestore Security Rules to restrict who can write and read events.

Open the Custom Code panel (</> in the left sidebar). In the Custom Actions tab, tap '+' and name the action 'logEvent'. Add these parameters: eventName (String, required), screenName (String, required), properties (JSON, optional). The action should write a document to the analytics_events collection using a fire-and-forget pattern — call the Firestore write but do NOT await it inside the UI-blocking action flow. Instead, use unawaited() from the dart:async library to start the Firestore write without blocking. This ensures your UI remains responsive even if the Firestore write is slow. Include the current user's UID and a session ID stored in app state.

1import 'dart:async';
2import 'package:firebase_auth/firebase_auth.dart';
3import 'package:cloud_firestore/cloud_firestore.dart';
4
5Future logEvent(
6  String eventName,
7  String screenName,
8  dynamic properties,
9) async {
10  final user = FirebaseAuth.instance.currentUser;
11  if (user == null) {
12    debugPrint('logEvent: skipped — no authenticated user');
13    return;
14  }
15
16  // Fire-and-forget: do not await the Firestore write
17  unawaited(
18    FirebaseFirestore.instance
19        .collection('analytics_events')
20        .add({
21      'event': eventName,
22      'screen': screenName,
23      'uid': user.uid,
24      'timestamp': FieldValue.serverTimestamp(),
25      'properties': properties ?? {},
26    }).catchError((e) {
27      debugPrint('logEvent write error: $e');
28    }),
29  );
30}

A session ID groups all events from a single app session together, making it easy to analyze complete user journeys. In FlutterFlow, go to the left sidebar → App State (the database-like icon). Add a new App State variable named 'sessionId' of type String with no default value. Next, on your app's initial page (or a splash screen), add an 'On Page Load' action: 'Update App State' → set sessionId to a Custom Function that generates a random ID. Create a Custom Function named 'generateSessionId' that returns a UUID-style random string. This ID persists for the app session and resets each time the app is launched fresh.

1// Custom Function: generateSessionId
2// Return type: String
3// No parameters
4String generateSessionId() {
5  final now = DateTime.now().millisecondsSinceEpoch.toString();
6  final rand = (1000000 + (9000000 * (DateTime.now().microsecond / 1000000))).toInt().toString();
7  return 'sess_${now}_$rand';
8}

Navigate to a page you want to track — for example, your Home page. In the page properties panel, find the 'On Page Load' action trigger and open the Action Flow editor. Add a new action step: 'Custom Action' → 'logEvent'. Set eventName to the string 'screen_view', set screenName to the page name (e.g., 'Home'), and leave properties empty or pass a JSON object with additional context. Repeat this for each important page in your app. FlutterFlow's On Page Load trigger fires every time the user navigates to that page, giving you a complete picture of navigation patterns.

For button tap tracking, open the Action Flow for any button you want to track. At the beginning of the Action Flow (before the main action), add a 'Custom Action' → 'logEvent' step. Set eventName to a descriptive name like 'button_tap', screenName to the current page name, and properties to a JSON object with the button's identity: {"button": "purchase_cta", "plan": selectedPlanVariable}. Place the logEvent call at the start of the flow so it fires even if a later action fails. Track form submissions, purchases, social shares, and any other high-value interactions. Avoid tracking every single widget interaction — focus on actions that represent meaningful user intent.

Open the Firebase Console → Firestore → analytics_events collection. Use the filter panel to narrow events by uid (your test user's UID), event type, or date range. Review the document structure to confirm all fields are populated correctly. For session analysis, filter by sessionId to see the complete sequence of events for one session. To query programmatically (for a future analytics dashboard in your app), create a Firestore query in FlutterFlow's Backend Query panel on a Repeating Group: collection 'analytics_events', filter by uid = currentUser.uid, order by timestamp descending, limit 50. This shows the most recent events for the logged-in user.