How to Create a News Feed Algorithm in FlutterFlow

Create a ranked_feed subcollection under each user document: users/{uid}/ranked_feed/{postId} with fields: postId (String), score (Double), title (String), authorName (String), thumbnailUrl (String), engagementCount (Integer), createdAt (Timestamp). Also create an algorithm_config document at the root level with fields: recency_weight (Double, default 0.4), engagement_weight (Double, default 0.35), affinity_weight (Double, default 0.25), decay_half_life_hours (Integer, default 24). This config document lets you tune the algorithm without changing code.

Create a Cloud Function that runs on a schedule (every 15 minutes). For each active user, it fetches all posts from the last 7 days and scores each one. The formula: score = (recency_weight * decay_function) + (engagement_weight * normalized_engagement) + (affinity_weight * author_interaction_score). The decay function uses exponential decay: 1 / (1 + age_hours / decay_half_life_hours). Normalized engagement = (likes + comments*2 + shares*3) / max_engagement_in_batch. Author interaction score = count of user's likes and comments on that author's previous posts / total_interactions. Apply a diversity penalty of -0.1 if the previous post in the ranked list is from the same author.

1// Cloud Function: rankFeed
2const functions = require('firebase-functions');
3const admin = require('firebase-admin');
4
5exports.rankFeed = functions.pubsub
6  .schedule('every 15 minutes').onRun(async () => {
7    const db = admin.firestore();
8    const config = (await db.doc('algorithm_config/default').get()).data();
9    const { recency_weight, engagement_weight,
10            affinity_weight, decay_half_life_hours } = config;
11    const now = Date.now();
12    const weekAgo = new Date(now - 7*24*60*60*1000);
13    const posts = await db.collection('posts')
14      .where('createdAt', '>=', weekAgo).get();
15    const maxEng = Math.max(...posts.docs.map(p => {
16      const d = p.data();
17      return d.likes + d.comments*2 + (d.shares||0)*3;
18    }), 1);
19    const users = await db.collection('users')
20      .where('lastActive', '>=', weekAgo).get();
21    for (const user of users.docs) {
22      const uid = user.id;
23      const interactions = await db
24        .collection('interactions')
25        .where('userId', '==', uid).get();
26      const authorScores = {};
27      let totalInt = Math.max(interactions.size, 1);
28      interactions.forEach(i => {
29        const a = i.data().authorId;
30        authorScores[a] = (authorScores[a]||0) + 1;
31      });
32      const scored = posts.docs.map(p => {
33        const d = p.data();
34        const ageH = (now - d.createdAt.toMillis())
35                     / 3600000;
36        const recency = 1 / (1 + ageH / decay_half_life_hours);
37        const eng = (d.likes + d.comments*2
38                     + (d.shares||0)*3) / maxEng;
39        const affinity = (authorScores[d.authorId]||0)
40                         / totalInt;
41        return {
42          postId: p.id, title: d.title,
43          authorName: d.authorName,
44          thumbnailUrl: d.thumbnailUrl || '',
45          engagementCount: d.likes + d.comments,
46          createdAt: d.createdAt,
47          score: recency_weight * recency
48               + engagement_weight * eng
49               + affinity_weight * affinity
50        };
51      }).sort((a,b) => b.score - a.score);
52      // Diversity penalty
53      for (let i = 1; i < scored.length; i++) {
54        if (scored[i].authorName === scored[i-1].authorName)
55          scored[i].score -= 0.1;
56      }
57      scored.sort((a,b) => b.score - a.score);
58      const batch = db.batch();
59      const feedRef = db.collection(`users/${uid}/ranked_feed`);
60      const old = await feedRef.get();
61      old.forEach(d => batch.delete(d.ref));
62      scored.slice(0, 50).forEach(s => {
63        batch.set(feedRef.doc(s.postId), s);
64      });
65      await batch.commit();
66    }
67  });

Build an AlgorithmConfigPage accessible to admin users. Add three Slider widgets labeled Recency Weight, Engagement Weight, and Affinity Weight, each ranging from 0.0 to 1.0. Bind their initial values to a Backend Query on algorithm_config/default. Add a TextField for decay_half_life_hours. Include a Save button that updates the algorithm_config document with the new values. Add a note Text widget reminding that changes take effect on the next Cloud Function run (within 15 minutes). This lets you tune ranking live without code changes.

Create a FeedPage with ChoiceChips at the top: For You and Latest. For the For You tab, add a ListView with a Backend Query on users/{currentUser.uid}/ranked_feed ordered by score descending. For the Latest tab, query the posts collection ordered by createdAt descending. Each list item is a PostCard Container with: thumbnail Image, title Text, author name Text, engagement count with icons, and relative timestamp. Tapping a card navigates to the full post detail page with the postId as a route parameter.

Create an interactions collection with fields: userId, postId, authorId, type (String: 'like', 'comment', 'share'), timestamp. When a user likes, comments, or shares a post, create an interaction document via an Action Flow. These interactions feed the affinity score in the ranking algorithm. The more a user interacts with a specific author's content, the higher that author's posts rank in their feed. The Cloud Function reads these interactions to calculate author_interaction_score per user.