How Facebook Built Friend Bubbles Social Discovery That Scales to Billions

The Simple Idea That Demanded Deep Engineering

At first glance, Friend Bubbles looks like a trivial UI enhancement: a small indicator that shows which Reels your friends have watched and reacted to. But as the Meta Tech Podcast episode with engineers Subasree and Joseph reveals, this feature required solving some of the hardest problems in social graph computation and real-time personalization.

The core challenge? Building a recommendation layer that surfaces friend activity without overwhelming users, while respecting privacy constraints and maintaining sub-50ms latency at Facebook's scale. Let's break down how they did it.

ML Model Evolution: From Cold Start to Personalization

The initial version of Friend Bubbles used a simple collaborative filtering approach: if your friend liked a Reel, show it. But this led to two problems:

1. Cold start: New users with few friends saw empty bubbles.
2. Signal dilution: Friends who engage with everything created noise.

The team iterated through three model generations:

• v1 (Rule-based): Show Reels if ≥2 friends interacted. Simple but static.
• v2 (LightGBM): Feature-engineered signals like friend affinity score, time since interaction, and content category match. Improved CTR by 34%.
• v3 (Graph Neural Network): Embedding the social graph directly into the recommendation pipeline. This allowed the model to learn which friend interactions are most predictive of your own engagement.

# Simplified GNN training loop for friend affinity prediction
import torch
import torch.nn.functional as F
from torch_geometric.nn import GCNConv

class FriendAffinityGNN(torch.nn.Module):
    def __init__(self, in_channels, hidden_channels, out_channels):
        super().__init__()
        self.conv1 = GCNConv(in_channels, hidden_channels)
        self.conv2 = GCNConv(hidden_channels, out_channels)
    
    def forward(self, x, edge_index):
        # x: node features (user embeddings + content embeddings)
        # edge_index: social graph edges (friend connections)
        x = self.conv1(x, edge_index)
        x = F.relu(x)
        x = F.dropout(x, training=self.training)
        x = self.conv2(x, edge_index)
        return F.log_softmax(x, dim=1)

iOS vs Android: The Behavioral Divide

One surprising discovery was that iOS and Android users interacted with Friend Bubbles very differently:

This led the team to implement platform-specific models: on iOS, the model prioritized recency (since users skim quickly), while on Android it emphasized diversity (since users explored more). The code for the platform-specific feature transformation:

# Platform-specific feature engineering
if user_platform == 'ios':
    features['recency_score'] = compute_recency(timestamp) * 1.5
    features['friend_diversity'] = compute_diversity(friend_set) * 0.8
else:  # android
    features['recency_score'] = compute_recency(timestamp) * 0.9
    features['friend_diversity'] = compute_diversity(friend_set) * 1.3

The Surprising Discovery That Made It Click

The breakthrough came when the team realized that friend bubbles work best when they show content your friends haven't seen yet. The original assumption was to show already-watched Reels (social proof), but engagement was 3x higher when the bubble highlighted Reels that friends were likely to watch next.

This shifted the model from a retrospective to a predictive task: instead of "what did my friends watch?", the question became "what would my friends watch next?" The team used a temporal graph attention mechanism to forecast future interactions:

# Temporal attention for predicting future friend interactions
class TemporalAttention(torch.nn.Module):
    def __init__(self, hidden_dim):
        super().__init__()
        self.query = torch.nn.Linear(hidden_dim, hidden_dim)
        self.key = torch.nn.Linear(hidden_dim, hidden_dim)
        self.temporal_encoding = torch.nn.Embedding(1000, hidden_dim)  # time buckets
    
    def forward(self, user_emb, friend_embs, timestamps):
        # Add temporal bias to friend embeddings
        time_enc = self.temporal_encoding(timestamps // 3600)  # hour buckets
        friend_embs = friend_embs + time_enc
        
        # Attention over future interactions
        attn_scores = torch.matmul(self.query(user_emb), self.key(friend_embs).T)
        attn_weights = F.softmax(attn_scores, dim=-1)
        return torch.matmul(attn_weights, friend_embs)

Limitations & Caveats

• Privacy concerns: Even aggregated friend activity can leak information. The team implemented differential privacy on aggregated counts.
• Friend churn: If a user loses connections, the feature degrades. Fallback to trending Reels is essential.
• Battery impact: Real-time polling for friend updates drained battery on older devices. Switched to push-based updates.

Next Steps & Learning Path

• Explore Graph Neural Networks for social recommendation
• Read about Meta's privacy-preserving ML techniques
• For a broader look at scaling social features, check out our guide on NVIDIA DOCA In-Silicon Security for AI factories

Conclusion

Friend Bubbles is a masterclass in how "simple" features require deep cross-functional engineering: ML, backend, client, and privacy. The key takeaway? Don't underestimate the complexity of social discovery at scale. Start with a simple rule-based model, iterate with platform-specific insights, and always question your assumptions about user behavior.

For more on building intelligent recommendation systems, see our deep dive on automating contract intelligence with Doczy.ai on AWS.

Source: Meta Tech Podcast – Engineering Friend Bubbles. Full episode available at engineering.fb.com.