Engineering Social Discovery at Scale: The Story Behind Facebook's Friend Bubbles

At first glance, Facebook's Friend Bubbles feature appears deceptively simple: it highlights Reels that your friends have watched and reacted to. Yet beneath that straightforward interface lies a complex engineering story — one that involved refining machine learning models, tackling divergent user behaviors on iOS and Android, and a eureka moment that unlocked the feature's full potential.

In the latest episode of the Meta Tech Podcast, host Pascal Hartig sits down with engineers Subasree and Joseph from the Facebook Reels team to unpack the technical journey behind Friend Bubbles. This article distills their insights into a deep dive on building social discovery features that scale to billions of users.

Friend Bubbles isn't just about showing which Reels friends have seen; it's about surfacing the most relevant ones in a personalized feed. That required a machine learning model that could predict what content would spark engagement within a user's social circle. The team started with a baseline recommendation algorithm but quickly noticed that friend-based signals behaved differently than interest-based ones.

Subasree explains, "We had to shift from predicting 'what will you watch' to 'what will your friends want you to know they watched.'" This subtle reframing led to a series of iterations where the model learned to weigh recency, frequency of friend reactions, and even the user's own viewing history. The final architecture balances collaborative filtering with graph-based features, ensuring that a friend's reaction — whether a like, comment, or share — carries appropriate influence without overwhelming the user.

To maintain performance at scale, the team introduced lightweight embedding layers that compressed social graph data into efficient vector representations. This allowed the model to update predictions in near real-time as friends engaged with new Reels.

One of the most surprising engineering hurdles was the divergent behavior between iOS and Android users. While the core logic remained identical, the way notifications and in-app experiences triggered social discovery differed significantly.

• iOS: Apple's push notification settings and app background refresh limits meant that Friend Bubbles data sometimes arrived in batches. This required a smarter caching strategy to avoid stale content appearing "new."
• Android: The open ecosystem allowed more frequent background syncing, but fragmentation across phone models meant performance profiling had to cover dozens of configurations. Battery optimization became a key concern.

Joseph notes, "We had to design the feature to feel equally responsive on both platforms, even though the underlying sync rhythms were completely different." The solution? A unified server-side scheduler that adaptively pushed updates based on each device's availability and user engagement patterns, rather than a one-size-fits-all polling interval.

The feature initially underperformed in beta tests. Users saw Friend Bubbles but didn't engage with them at the expected rate. After weeks of experimentation, the team made a counterintuitive finding: the bubbles were too accurate. By showing only the most popular Reels among friends, the feature inadvertently filtered out serendipitous or niche content that sparked conversation.

Subasree recalls, "We realized that social discovery isn't about being perfectly relevant — it's about creating moments of surprise and shared humor." The team adjusted the algorithm to inject controlled randomness and de-emphasize trending signals in favor of low-frequency friend interactions. For example, if a friend rarely reacts but suddenly likes a quirky Reel on woodworking, that bubble now gets priority over yet another viral dance clip.

This "serendipity knob" dramatically improved click-through rates and time spent. Joseph describes it as "the moment we stopped building a recommendation engine and started building a social icebreaker."

Behind the simple UI sits a distributed processing pipeline that ingests millions of friend interactions per second. The team built a stream processing layer using Apache Flink to aggregate reactions into per-user social graphs, then fed those into a real-time inference service.

1. Event collection: Every like, comment, and share on Reels is captured via Facebook's event bus.
2. Graph computation: A lightweight graph database computes friend circles and relationship strengths (e.g., close friends vs. acquaintances).
3. Candidate generation: The ML model scores potential bubbles based on recency, friend weight, and serendipity tuning.
4. Personalized ranking: The final list is re-ranked using a second model that accounts for the user's current session context (time of day, device, recent activity).

To handle load spikes — for instance, when a global event triggers a wave of Reel reactions — the team relies on auto-scaling Kubernetes clusters that spin up additional inference pods within seconds. Redundancy across multiple geographic regions ensures that Friend Bubbles remain responsive even if one data center experiences issues.

The story of Friend Bubbles is a testament to the hidden complexity behind seemingly simple features. What began as a straightforward "show what friends watched" concept required rethinking ML objectives, platform-specific adaptations, and a willingness to embrace serendipity over algorithmic perfection.

For the engineers at Meta, this feature is more than a technical achievement — it's a way to foster genuine social connections at scale. As Joseph puts it, "Every time someone sends a friend a funny Reel and it sparks a conversation, that's the magic we're building for."

If you're interested in tackling similar challenges, explore career opportunities at Meta by visiting their Careers page. For more behind-the-scenes engineering stories, listen to the Meta Tech Podcast on Spotify, Apple Podcasts, or Pocket Casts.