Design TikTok: From Zero to 1B Feeds with Real-World System Design

// io.thecodeforge — System Design tutorial

// Feed generation service: precomputes feeds for active users
// Active user = logged in within last 24h

class FeedGenerator {
    private final Cache<String, List<Video>> feedCache;
    private final VideoRanker ranker;
    private final CreatorGraph graph; // who user follows

    public List<Video> getFeed(String userId) {
        // Check cache first
        List<Video> cached = feedCache.get(userId);
        if (cached != null) return cached;

        // Fan-out-on-read: compute feed on demand
        Set<String> followees = graph.getFollowees(userId);
        List<Video> candidates = fetchRecentVideos(followees, 500);
        List<Video> ranked = ranker.rank(candidates, userId);
        feedCache.put(userId, ranked, Duration.ofMinutes(30));
        return ranked;
    }

    // Called when a creator uploads a new video
    public void onNewVideo(String creatorId, Video video) {
        // Fan-out-on-write: push to active followers
        Set<String> activeFollowers = graph.getActiveFollowers(creatorId);
        for (String followerId : activeFollowers) {
            feedCache.evict(followerId); // force recompute on next read
            // Alternatively, prepend to a precomputed list
        }
    }
}

// io.thecodeforge — System Design tutorial

// Video storage service with tiered caching

class VideoStorage {
    private final ObjectStore objectStore;
    private final Cache<String, byte[]> edgeCache; // small, fast
    private final Cache<String, byte[]> regionalCache; // larger, slower

    public byte[] getVideo(String videoId, String resolution) {
        String key = videoId + ":" + resolution;
        // Check edge cache first
        byte[] video = edgeCache.get(key);
        if (video != null) return video;

        // Check regional cache
        video = regionalCache.get(key);
        if (video != null) {
            edgeCache.put(key, video); // promote to edge
            return video;
        }

        // Fetch from object store
        video = objectStore.get(key);
        // Only cache in edge if video is viral (views > threshold)
        if (isViral(videoId)) {
            edgeCache.put(key, video);
        } else {
            regionalCache.put(key, video);
        }
        return video;
    }

    private boolean isViral(String videoId) {
        // Check view count in last hour from analytics
        return viewCountService.getHourlyViews(videoId) > 100_000;
    }
}

// io.thecodeforge — System Design tutorial

// Multi-stage recommendation pipeline

class RecommendationPipeline {
    private final CandidateRetriever retriever;
    private final RankingModel ranker;
    private final FilterChain filters;

    public List<Video> recommend(String userId, int count) {
        // Stage 1: Retrieve candidates (sub-50ms)
        List<Video> candidates = retriever.retrieve(userId, 500);

        // Stage 2: Rank using ML model (sub-100ms per batch)
        List<ScoredVideo> scored = ranker.score(candidates, userId);

        // Stage 3: Apply filters (diversity, freshness)
        List<Video> filtered = filters.apply(scored);

        return filtered.subList(0, Math.min(count, filtered.size()));
    }
}

class CandidateRetriever {
    // Multiple retrieval strategies
    public List<Video> retrieve(String userId, int limit) {
        List<Video> candidates = new ArrayList<>();
        candidates.addAll(getFolloweeVideos(userId, limit/4));
        candidates.addAll(getTrendingVideos(limit/4));
        candidates.addAll(getSimilarUserVideos(userId, limit/4));
        candidates.addAll(getContentBasedVideos(userId, limit/4));
        return candidates;
    }
}

// io.thecodeforge — System Design tutorial

// Circuit breaker for feed generation

class FeedCircuitBreaker {
    private final AtomicInteger failureCount = new AtomicInteger(0);
    private final int threshold = 10; // failures in 1 minute
    private volatile boolean open = false;

    public List<Video> getFeed(String userId) {
        if (open) {
            // Return stale cached feed
            return staleFeedCache.get(userId);
        }
        try {
            List<Video> feed = feedGenerator.getFeed(userId);
            failureCount.set(0);
            return feed;
        } catch (TimeoutException e) {
            int failures = failureCount.incrementAndGet();
            if (failures >= threshold) {
                open = true;
                // Schedule reset after 30 seconds
                scheduler.schedule(() -> open = false, 30, TimeUnit.SECONDS);
            }
            throw e;
        }
    }
}