Design Twitter/X Feed

// 1. Post Tweet
POST /api/v1/tweets
Request Body:
{
  "userId": 12345,
  "content": "Hello World! #Java",
  "mediaUrls": ["https://cdn.example.com/image.jpg"]
}
Response:
{
  "tweetId": 987654321,
  "userId": 12345,
  "content": "Hello World! #Java",
  "createdAt": "2024-01-15T10:30:00Z",
  "likes": 0,
  "retweets": 0
}
// 2. Get User Timeline (Feed)
GET /api/v1/timeline?userId=12345&page=1&pageSize=20
Response:
{
  "tweets": [
    {
      "tweetId": 999,
      "userId": 67890,
      "username": "alice",
      "content": "Excited about system design!",
      "createdAt": "2024-01-15T11:00:00Z",
      "likes": 42,
      "retweets": 5
    }
    // ... more tweets
  ],
  "nextPage": 2,
  "hasMore": true
}
// 3. Follow User
POST /api/v1/follow
Request Body:
{
  "followerId": 12345,
  "followeeId": 67890
}
// 4. Like Tweet
POST /api/v1/tweets/{tweetId}/like
Request Body:
{
  "userId": 12345
}
// 5. Retweet
POST /api/v1/tweets/{tweetId}/retweet
Request Body:
{
  "userId": 12345,
  "comment": "Great insight!" // optional
}

-- Users Table
CREATE TABLE users (
    user_id BIGINT PRIMARY KEY AUTO_INCREMENT,
    username VARCHAR(50) UNIQUE NOT NULL,
    email VARCHAR(255) UNIQUE NOT NULL,
    bio TEXT,
    profile_image_url VARCHAR(500),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    followers_count INT DEFAULT 0,
    following_count INT DEFAULT 0,
    INDEX idx_username (username)
);
-- Tweets Table (Use NoSQL like Cassandra in production)
CREATE TABLE tweets (
    tweet_id BIGINT PRIMARY KEY AUTO_INCREMENT,
    user_id BIGINT NOT NULL,
    content VARCHAR(280) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    likes_count INT DEFAULT 0,
    retweets_count INT DEFAULT 0,
    replies_count INT DEFAULT 0,
    FOREIGN KEY (user_id) REFERENCES users(user_id),
    INDEX idx_user_created (user_id, created_at DESC)
);
-- Followers Table (Relationships)
CREATE TABLE followers (
    follower_id BIGINT NOT NULL,
    followee_id BIGINT NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    PRIMARY KEY (follower_id, followee_id),
    FOREIGN KEY (follower_id) REFERENCES users(user_id),
    FOREIGN KEY (followee_id) REFERENCES users(user_id),
    INDEX idx_followee (followee_id)
);
-- Timeline/Feed Cache Table (Pre-computed feeds)
CREATE TABLE user_timeline (
    user_id BIGINT NOT NULL,
    tweet_id BIGINT NOT NULL,
    tweet_created_at TIMESTAMP NOT NULL,
    PRIMARY KEY (user_id, tweet_created_at, tweet_id),
    INDEX idx_user_timeline (user_id, tweet_created_at DESC)
);
-- Likes Table
CREATE TABLE likes (
    user_id BIGINT NOT NULL,
    tweet_id BIGINT NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    PRIMARY KEY (user_id, tweet_id),
    FOREIGN KEY (user_id) REFERENCES users(user_id),
    FOREIGN KEY (tweet_id) REFERENCES tweets(tweet_id),
    INDEX idx_tweet_likes (tweet_id)
);

public class FeedGenerationService {
    private final TweetRepository tweetRepository;
    private final FollowerRepository followerRepository;
    private final CacheService cacheService;
    private final MessageQueueService messageQueue;
    /**
     * Post tweet and fanout to followers (Hybrid approach)
     */
    public Tweet postTweet(long userId, String content) {
        // 1. Save tweet to database
        Tweet tweet = tweetRepository.save(new Tweet(userId, content));
        // 2. Check user's follower count
        int followerCount = followerRepository.getFollowerCount(userId);
        if (followerCount < 1_000_000) {
            // Regular user: Fan-out on write (push to followers)
            fanoutOnWrite(tweet);
        } else {
            // Celebrity: Fan-out on read (pull when requested)
            // Just cache the tweet for fast access
            cacheService.cacheTweet(tweet);
        }
        return tweet;
    }
    /**
     * Fan-out on write: Push tweet to all followers' feeds
     */
    private void fanoutOnWrite(Tweet tweet) {
        // Publish to message queue for async processing
        messageQueue.publish("fanout-queue", tweet);
        // Workers will consume and push to followers' feeds
        // This prevents blocking the API response
    }
    /**
     * Get user timeline (feed)
     */
    public List<Tweet> getTimeline(long userId, int page, int pageSize) {
        String cacheKey = "timeline:" + userId + ":" + page;
        // 1. Check cache first
        List<Tweet> cachedFeed = cacheService.get(cacheKey);
        if (cachedFeed != null) {
            return cachedFeed;
        }
        // 2. Get list of users this user follows
        List<Long> followingIds = followerRepository.getFollowing(userId);
        // 3. Check if any following are celebrities
        List<Long> celebrities = filterCelebrities(followingIds);
        List<Long> regularUsers = filterRegularUsers(followingIds);
        List<Tweet> feed = new ArrayList<>();
        // 4. For regular users: Get from pre-computed timeline
        if (!regularUsers.isEmpty()) {
            feed.addAll(getPrecomputedTimeline(userId, page, pageSize));
        }
        // 5. For celebrities: Fan-out on read (pull their latest tweets)
        if (!celebrities.isEmpty()) {
            feed.addAll(getLatestTweetsFromCelebrities(celebrities, pageSize));
        }
        // 6. Merge and sort by timestamp (most recent first)
        feed.sort((a, b) -> b.getCreatedAt().compareTo(a.getCreatedAt()));
        // 7. Take only pageSize tweets
        feed = feed.subList(0, Math.min(pageSize, feed.size()));
        // 8. Cache the result
        cacheService.set(cacheKey, feed, 300); // 5 min TTL
        return feed;
    }
    private List<Long> filterCelebrities(List<Long> userIds) {
        return userIds.stream()
            .filter(id -> followerRepository.getFollowerCount(id) > 1_000_000)
            .collect(Collectors.toList());
    }
    private List<Long> filterRegularUsers(List<Long> userIds) {
        return userIds.stream()
            .filter(id -> followerRepository.getFollowerCount(id) <= 1_000_000)
            .collect(Collectors.toList());
    }
    private List<Tweet> getPrecomputedTimeline(long userId, int page, int pageSize) {
        int offset = (page - 1) * pageSize;
        return tweetRepository.getUserTimeline(userId, offset, pageSize);
    }
    private List<Tweet> getLatestTweetsFromCelebrities(
            List<Long> celebrityIds, int limit) {
        // Pull latest tweets from celebrities
        return tweetRepository.getLatestTweets(celebrityIds, limit);
    }
}
/**
 * Fanout Worker - Consumes from message queue
 */
public class FanoutWorker {
    private final FollowerRepository followerRepository;
    private final TimelineRepository timelineRepository;
    private final MessageQueueService messageQueue;
    public void start() {
        messageQueue.consume("fanout-queue", this::processFanout);
    }
    private void processFanout(Tweet tweet) {
        // Get all followers of the user who posted the tweet
        List<Long> followerIds = followerRepository.getFollowers(tweet.getUserId());
        // Push tweet to each follower's timeline (batch insert)
        for (Long followerId : followerIds) {
            timelineRepository.addToTimeline(followerId, tweet.getTweetId());
        }
        System.out.println("Fanned out tweet " + tweet.getTweetId() +
                           " to " + followerIds.size() + " followers");
    }
}