Design Instagram

// 1. Upload Photo
POST /api/v1/posts
Request (multipart/form-data):
{
  "userId": 12345,
  "caption": "Beautiful sunset! #nature #photography",
  "location": "San Francisco, CA",
  "images": [file1.jpg, file2.jpg]  // max 10 images
}
Response:
{
  "postId": 987654321,
  "userId": 12345,
  "caption": "Beautiful sunset! #nature #photography",
  "imageUrls": [
    "https://cdn.instagram.com/p/987654321/image_0.jpg",
    "https://cdn.instagram.com/p/987654321/image_1.jpg"
  ],
  "thumbnailUrls": [
    "https://cdn.instagram.com/p/987654321/thumb_0.jpg",
    "https://cdn.instagram.com/p/987654321/thumb_1.jpg"
  ],
  "createdAt": "2024-01-15T10:30:00Z",
  "likes": 0,
  "comments": 0
}
// 2. Get User Feed
GET /api/v1/feed?userId=12345&page=1&pageSize=20
Response:
{
  "posts": [
    {
      "postId": 999,
      "userId": 67890,
      "username": "alice_photos",
      "profilePicUrl": "https://cdn.instagram.com/u/67890/profile.jpg",
      "caption": "Morning coffee ☕",
      "imageUrls": ["https://cdn.instagram.com/p/999/image_0.jpg"],
      "thumbnailUrls": ["https://cdn.instagram.com/p/999/thumb_0.jpg"],
      "likes": 245,
      "comments": 12,
      "createdAt": "2024-01-15T09:00:00Z"
    }
    // ... more posts
  ],
  "nextPage": 2,
  "hasMore": true
}
// 3. Like Post
POST /api/v1/posts/{postId}/like
Request Body:
{
  "userId": 12345
}
// 4. Comment on Post
POST /api/v1/posts/{postId}/comments
Request Body:
{
  "userId": 12345,
  "text": "Amazing photo!"
}
// 5. Follow User
POST /api/v1/follow
Request Body:
{
  "followerId": 12345,
  "followeeId": 67890
}
// 6. Search Users/Hashtags
GET /api/v1/search?q=nature&type=hashtag&page=1
Response:
{
  "results": [
    {
      "hashtag": "#nature",
      "postCount": 1234567,
      "recentPosts": [...]
    }
  ]
}

-- Users Table (MySQL/PostgreSQL)
CREATE TABLE users (
    user_id BIGINT PRIMARY KEY AUTO_INCREMENT,
    username VARCHAR(50) UNIQUE NOT NULL,
    email VARCHAR(255) UNIQUE NOT NULL,
    password_hash VARCHAR(255) NOT NULL,
    full_name VARCHAR(100),
    bio TEXT,
    profile_pic_url VARCHAR(500),
    followers_count INT DEFAULT 0,
    following_count INT DEFAULT 0,
    posts_count INT DEFAULT 0,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    INDEX idx_username (username),
    INDEX idx_email (email)
);
-- Posts Table (Cassandra recommended for scale)
CREATE TABLE posts (
    post_id BIGINT PRIMARY KEY AUTO_INCREMENT,
    user_id BIGINT NOT NULL,
    caption TEXT,
    location VARCHAR(255),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    likes_count INT DEFAULT 0,
    comments_count INT DEFAULT 0,
    FOREIGN KEY (user_id) REFERENCES users(user_id),
    INDEX idx_user_created (user_id, created_at DESC)
);
-- Post Images Table (multiple images per post)
CREATE TABLE post_images (
    image_id BIGINT PRIMARY KEY AUTO_INCREMENT,
    post_id BIGINT NOT NULL,
    image_url VARCHAR(500) NOT NULL,
    thumbnail_url VARCHAR(500) NOT NULL,
    order_index INT DEFAULT 0,
    width INT,
    height INT,
    FOREIGN KEY (post_id) REFERENCES posts(post_id),
    INDEX idx_post (post_id)
);
-- Followers Table (relationship graph)
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),
    INDEX idx_follower (follower_id)
);
-- Likes Table
CREATE TABLE likes (
    user_id BIGINT NOT NULL,
    post_id BIGINT NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    PRIMARY KEY (user_id, post_id),
    FOREIGN KEY (user_id) REFERENCES users(user_id),
    FOREIGN KEY (post_id) REFERENCES posts(post_id),
    INDEX idx_post_likes (post_id, created_at DESC)
);
-- Comments Table
CREATE TABLE comments (
    comment_id BIGINT PRIMARY KEY AUTO_INCREMENT,
    post_id BIGINT NOT NULL,
    user_id BIGINT NOT NULL,
    text TEXT NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (post_id) REFERENCES posts(post_id),
    FOREIGN KEY (user_id) REFERENCES users(user_id),
    INDEX idx_post_comments (post_id, created_at DESC)
);
-- Feed Table (Pre-computed feeds - Cassandra)
CREATE TABLE user_feed (
    user_id BIGINT NOT NULL,
    post_id BIGINT NOT NULL,
    post_created_at TIMESTAMP NOT NULL,
    PRIMARY KEY (user_id, post_created_at, post_id)
) WITH CLUSTERING ORDER BY (post_created_at DESC, post_id DESC);

public class ImageProcessingService {
    private final S3Client s3Client;
    private final DatabaseService dbService;
    private final MessageQueueService messageQueue;
    /**
     * Process uploaded image asynchronously
     */
    public void processImage(ImageUploadEvent event) {
        try {
            // 1. Download original image from temp storage
            byte[] originalImage = s3Client.download(event.getTempUrl());
            // 2. Compress image (reduce size by ~90%)
            byte[] compressedImage = compressImage(originalImage, 80); // 80% quality
            // 3. Generate thumbnails
            byte[] thumbnail150 = resizeImage(compressedImage, 150, 150);
            byte[] thumbnail640 = resizeImage(compressedImage, 640, 640);
            // 4. Upload to permanent storage
            String imageKey = "posts/" + event.getPostId() + "/image.webp";
            String thumb150Key = "posts/" + event.getPostId() + "/thumb_150.webp";
            String thumb640Key = "posts/" + event.getPostId() + "/thumb_640.webp";
            s3Client.upload(imageKey, compressedImage);
            s3Client.upload(thumb150Key, thumbnail150);
            s3Client.upload(thumb640Key, thumbnail640);
            // 5. Get CDN URLs
            String imageUrl = getCdnUrl(imageKey);
            String thumbnail150Url = getCdnUrl(thumb150Key);
            String thumbnail640Url = getCdnUrl(thumb640Key);
            // 6. Save metadata to database
            PostImage postImage = new PostImage();
            postImage.setPostId(event.getPostId());
            postImage.setImageUrl(imageUrl);
            postImage.setThumbnailUrl(thumbnail640Url);
            postImage.setWidth(event.getWidth());
            postImage.setHeight(event.getHeight());
            dbService.savePostImage(postImage);
            // 7. Delete temp file
            s3Client.delete(event.getTempUrl());
            System.out.println("Image processed successfully: " + imageUrl);
        } catch (Exception e) {
            System.err.println("Failed to process image: " + e.getMessage());
            // Retry logic or dead letter queue
        }
    }
    private byte[] compressImage(byte[] image, int quality) {
        // Use ImageIO or external library (e.g., TwelveMonkeys, WebP Java)
        // Compress to WebP format with specified quality
        // Return compressed bytes
        return new byte[0]; // Placeholder
    }
    private byte[] resizeImage(byte[] image, int width, int height) {
        // Resize image to specified dimensions maintaining aspect ratio
        // Use library like Thumbnailator or imgscalr
        return new byte[0]; // Placeholder
    }
    private String getCdnUrl(String s3Key) {
        // Return CloudFront/CDN URL for the S3 key
        return "https://cdn.instagram.com/" + s3Key;
    }
}

public class FeedService {
    private final PostRepository postRepository;
    private final FollowerRepository followerRepository;
    private final CacheService cacheService;
    private final RankingService rankingService;
    private static final int CELEBRITY_THRESHOLD = 10_000;
    /**
     * Get ranked feed for user (hybrid approach)
     */
    public List<Post> getFeed(long userId, int page, int pageSize) {
        String cacheKey = "feed:" + userId + ":" + page;
        // 1. Check cache
        List<Post> cachedFeed = cacheService.get(cacheKey);
        if (cachedFeed != null) {
            return cachedFeed;
        }
        // 2. Get users this user follows
        List<Long> followingIds = followerRepository.getFollowing(userId);
        // 3. Separate celebrities from regular users
        List<Long> celebrities = new ArrayList<>();
        List<Long> regularUsers = new ArrayList<>();
        for (Long followeeId : followingIds) {
            int followerCount = followerRepository.getFollowerCount(followeeId);
            if (followerCount > CELEBRITY_THRESHOLD) {
                celebrities.add(followeeId);
            } else {
                regularUsers.add(followeeId);
            }
        }
        List<Post> allPosts = new ArrayList<>();
        // 4. For regular users: get from pre-computed feed (push-based)
        if (!regularUsers.isEmpty()) {
            allPosts.addAll(getPrecomputedFeed(userId, pageSize));
        }
        // 5. For celebrities: fetch their recent posts (pull-based)
        if (!celebrities.isEmpty()) {
            allPosts.addAll(getRecentPostsFrom(celebrities, pageSize));
        }
        // 6. Rank posts using ML algorithm
        List<Post> rankedPosts = rankingService.rankPosts(userId, allPosts);
        // 7. Paginate
        int offset = (page - 1) * pageSize;
        rankedPosts = rankedPosts.subList(
            offset,
            Math.min(offset + pageSize, rankedPosts.size())
        );
        // 8. Cache the result
        cacheService.set(cacheKey, rankedPosts, 300); // 5 min TTL
        return rankedPosts;
    }
    private List<Post> getPrecomputedFeed(long userId, int limit) {
        // Get posts from user_feed table (pre-computed during fanout)
        return postRepository.getUserFeed(userId, limit);
    }
    private List<Post> getRecentPostsFrom(List<Long> userIds, int limit) {
        // Pull recent posts from these users
        return postRepository.getRecentPosts(userIds, limit);
    }
}
/**
 * Ranking Service using ML algorithm
 */
public class RankingService {
    /**
     * Rank posts based on multiple signals
     */
    public List<Post> rankPosts(long userId, List<Post> posts) {
        // Calculate engagement score for each post
        List<ScoredPost> scoredPosts = new ArrayList<>();
        for (Post post : posts) {
            double score = calculateScore(userId, post);
            scoredPosts.add(new ScoredPost(post, score));
        }
        // Sort by score (descending)
        scoredPosts.sort((a, b) -> Double.compare(b.score, a.score));
        // Return sorted posts
        return scoredPosts.stream()
            .map(sp -> sp.post)
            .collect(Collectors.toList());
    }
    private double calculateScore(long userId, Post post) {
        double score = 0.0;
        // 1. Engagement score (40% weight)
        double engagementScore =
            post.getLikes() * 1.0 +
            post.getComments() * 3.0 +
            post.getShares() * 5.0;
        score += engagementScore * 0.4;
        // 2. Time decay (30% weight) - newer posts score higher
        long ageInHours = ChronoUnit.HOURS.between(
            post.getCreatedAt(),
            Instant.now()
        );
        double timeScore = Math.exp(-ageInHours / 24.0) * 100; // Exponential decay
        score += timeScore * 0.3;
        // 3. User affinity (20% weight) - how often user interacts with this author
        double affinityScore = getUserAffinity(userId, post.getUserId());
        score += affinityScore * 0.2;
        // 4. Content type (10% weight) - videos might score higher
        double contentScore = post.isVideo() ? 10.0 : 5.0;
        score += contentScore * 0.1;
        return score;
    }
    private double getUserAffinity(long userId, long authorId) {
        // Calculate based on past interactions (likes, comments, views)
        // Return score 0-100
        return 50.0; // Placeholder
    }
    private static class ScoredPost {
        Post post;
        double score;
        ScoredPost(Post post, double score) {
            this.post = post;
            this.score = score;
        }
    }
}