System Design - How Instagram Delivers Reels Instantly (Case Study)
The most crucial step in the feed process is not video delivery it is the ranking and selection. A slow recommendation engine means the user stops scrolling.
The design discussed below is a high-level speculation based on common industry best practices for massive scale social media feeds, known architectural requirements (like low-latency ranking and caching), and public domain information. The actual implementation and technologies used by Instagram may differ significantly.
Instagram Reels and TikTok represent one of the greatest engineering feats in modern system design the infinite scroll. Unlike a fixed website or a linear video stream a feed must be instantly personalized and seemingly limitless.
The problem for Instagram is two fold.
The Ranking Problem
For every scroll the system must instantly decide which of the 10 billion available videos is the best one to show you next.
The Delivery Problem
Once the video is chosen it must begin playing in a fraction of a second before your finger scrolls past it.
The solution is a layered architectural approach that relies on Extreme Read Optimization Caches and Predictive Pre-Fetching.
The Ranking Engine
The most crucial step in the feed process is not video delivery it is the ranking and selection. A slow recommendation engine means the user stops scrolling.
The Candidate Generation Phase
When you open Reels the system does not check all 10 billion videos. It runs a fast query to generate a pool of Candidate Videos from sources like the people you follow your general interests and very popular videos.
This phase is extremely high-speed usually relying on the fastest possible databases and simple filtering logic to narrow the pool down from billions to about 5,000 relevant videos. This is the first essential step in capacity planning (Blog 7) reducing the load immediately.
The Multi Layered Filtering and Ranking
The 5,000 candidates are then passed through multiple ranking models each more complex than the last.
Layer 1 (Fast Filters)
The 5,000 videos are immediately filtered to remove duplicates videos you have already seen and any inappropriate content.
Layer 2 (Intermediate Ranking)
A medium-complexity machine learning model gives each video a Relevance Score based on your history. This might reduce the pool to about 500 videos.
Layer 3 (Deep Neural Networks or DNN)
Only the top 500 videos are passed to the most resource intensive models (the DNNs). These models apply hundreds of features (likes time watched sound used) to assign a final, precise ranking.
Finally, the system selects the Top 50 best videos for your session.
The Feed Pre Generation and Caching
The list of 50 ranked video IDs is then served to the user’s app. This list is your entire session’s feed until you close the app. To make the videos load instantly two major architectural steps are taken.
Feed Caching
The entire personalized list of 50 video IDs is stored in a fast, in-memory Key Value Cache (like Redis or Memcached).
Key - Your User ID.
Value - The JSON list of 50 ranked Reel IDs.
When you open the app the system bypasses all the complex ranking models and simply retrieves your pre calculated list from the cache. This is why the feed loads instantly. The hard work was done asynchronously (Blog 9) hours ago.
Video Storage and CDNs
The actual video files themselves are too large to store in the ranking database. They are stored in massive, distributed Blob Storage (like Amazon S3).
Like Netflix the delivery relies on a global Content Delivery Network (CDN). The video URL provided in your pre calculated feed points directly to the closest CDN Edge location.
The Client Side Magic (Pre-Fetching)
Even with the fastest CDN delivery is still limited by the speed of your phone’s network connection. This is where the client side magic happens through Predictive Pre-Fetching.
Pre-Fetching the Next Video
Your phone’s app does not wait for you to swipe up to load the next video.
When you are watching video #1 the app instantly starts downloading and buffering the first 2 seconds of video #2.
When you start watching video #2 the app begins downloading video #3.
This is a form of Asynchronous Pipelining moving the delivery work to the background so that the next video is already sitting on your phone waiting to play the moment you swipe up. This eliminates the perceivable delay.
Adaptive Bitrate (ABR)
To ensure the video starts instantly even on a slow 3G connection the video delivery uses Adaptive Bitrate Streaming (ABR).
The video is encoded in multiple qualities (e.g. 240p 480p 720p 1080p).
The first segment downloaded is always the lowest quality (240p). This is a tiny file that loads almost instantly ensuring the video starts playing in a fraction of a second.
Once the stream is started and the client detects a fast connection it seamlessly switches to downloading higher quality segments. This provides the user with an instant start and a high quality experience once the connection is proven stable.
Conclusion
Instagram’s reel delivery is a testament to the power of prediction and pre-computation. They solved the problem of scale by prioritizing reads and doing the heavy lifting before the user ever shows up.
Ranking Decoupling
The expensive ranking calculation is separated from the fast serving layer.
Pre-Calculation
The final feed is computed and stored in a fast Cache hours ahead of time.
Pre-Fetching
The client application uses Asynchronous background tasks to download the next video segment before the user asks for it.
This case study gives us perfect context for our next system design discussion which must address the challenge of data storage at this extreme scale. In our next blog post we will discuss Database Sharding Strategies the critical technique used to manage the sheer volume of users and content that giants like Instagram handle.