┌─────────────────────────────────────────────────────────────────┐
│                        Client Layer                             │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐                     │
│  │   iOS    │  │ Android  │  │   Web    │                     │
│  │   App    │  │   App    │  │ Browser  │                     │
│  └────┬─────┘  └────┬─────┘  └────┬─────┘                     │
└───────┼─────────────┼─────────────┼──────────────────────────────┘
        │             │             │
        └─────────────┴─────────────┘
                      │
        ┌─────────────┴─────────────┐
        │   Global Load Balancer    │
        │   (GeoDNS + Anycast)      │
        └─────────────┬─────────────┘
                      │
        ┌─────────────┴─────────────┐
        │      API Gateway          │
        │  (Auth, Rate Limit, SSL)  │
        └─────────────┬─────────────┘
                      │
        ┌─────────────┴──────────────────────────────┐
        │                                            │
┌───────┴────────┐                    ┌──────────────┴──────────┐
│  Upload Path   │                    │     Feed Path           │
│  (Media Post)  │                    │  (Content Fetch)        │
└───────┬────────┘                    └──────────────┬──────────┘
        │                                           │
┌───────┴────────┐                    ┌──────────────┴──────────┐
│  Upload Service│                    │  Feed Service           │
└───────┬────────┘                    └──────────────┬──────────┘
        │                                           │
┌───────┴────────┐                    ┌──────────────┴──────────┐
│  Media         │                    │  Feed Cache             │
│  Processing    │                    │  (Redis)                │
└───────┬────────┘                    └──────────────┬──────────┘
        │                                           │
┌───────┴────────┐                    ┌──────────────┴──────────┐
│  S3 Storage    │                    │  Feed DB                │
│  + CDN         │                    │  (Cassandra)            │
└────────────────┘                    └─────────────────────────┘

1. Client requests upload URL
2. Upload Service generates pre-signed S3 URL
3. Client uploads directly to S3
4. S3 triggers Lambda/SNS notification
5. Media Processing Service processes file
6. Metadata stored in database
7. CDN cache warmed
8. User notified of completion

┌─────────────────┐
│  S3 Upload      │
└────────┬────────┘
         │
┌────────┴────────┐
│  SQS Queue      │
└────────┬────────┘
         │
┌────────┴────────────────────────┐
│  Processing Workers (GPU)       │
│  - Image: Resize, Compress      │
│  - Video: Transcode, Thumbnail  │
│  - ML: NSFW, Face Detection     │
└────────┬────────────────────────┘
         │
┌────────┴────────┐
│  Store Processed│
│  Media in S3    │
└────────┬────────┘
         │
┌────────┴────────┐
│  Update Metadata│
│  in Database    │
└────────┬────────┘
         │
┌────────┴────────┐
│  Warm CDN Cache │
└─────────────────┘

Hybrid Approach:
1. Regular Users (<10K followers):
   - Fan-out on write (push model)
   - Pre-compute feed when post is created
   - Store in Cassandra partitioned by user_id

2. Celebrity Users (>1M followers):
   - Fan-out on read (pull model)
   - Fetch posts on-demand
   - Merge with pre-computed feed
   - Cache aggressively

3. Feed Ranking:
   - Fetch candidate posts (1000+)
   - Score using ML model
   - Rank by score
   - Apply business rules (diversity, freshness)
   - Return top 20 posts

Score = f(
  recency (time since post),
  engagement (likes, comments, shares),
  user affinity (interaction history with author),
  content type (photo, video, carousel),
  media quality (resolution, clarity),
  hashtag relevance,
  location relevance
)

ML Model:
- Input: User features + Post features
- Output: Engagement probability (0-1)
- Training: Offline on historical data
- Serving: Real-time feature computation

Story Upload:
1. Upload to S3 with 24h lifecycle policy
2. Store metadata in Redis (TTL: 24h)
3. Publish event to Kafka
4. Fan-out to followers (push notification)

Story Viewing:
1. Fetch active stories from Redis
2. If miss, query database
3. Check if already viewed
4. Increment view count
5. Mark as viewed for user
6. Return story with analytics

Story Expiration:
1. S3 lifecycle policy deletes after 24h
2. Redis TTL expires keys
3. Background job cleans database
4. CDN cache invalidation

Following Relationship (Cassandra):
CREATE TABLE following (
  user_id BIGINT,
  following_id BIGINT,
  followed_at TIMESTAMP,
  PRIMARY KEY (user_id, following_id)
);

Followers Relationship (Cassandra):
CREATE TABLE followers (
  user_id BIGINT,
  follower_id BIGINT,
  followed_at TIMESTAMP,
  PRIMARY KEY (user_id, follower_id)
);

Cache (Redis):
Key: followers:{user_id}
Value: Set of follower_ids
TTL: 1 hour

Key: following:{user_id}
Value: Set of following_ids
TTL: 1 hour

Like Post:
1. Client sends like request
2. Engagement Service validates
3. Write to database (async)
4. Update like count (eventual consistency)
5. Publish event to Kafka
6. Notification Service sends notification
7. Update cache
8. Return success to client

Comment on Post:
1. Client sends comment
2. Validate content (spam, profanity)
3. Store comment in database
4. Update comment count
5. Publish event to Kafka
6. Notification Service notifies post author
7. Return comment to client

Indexing Pipeline:
Post Created → Kafka → Indexing Worker → Elasticsearch

Search Query:
Client → Search Service → Elasticsearch → Results

Index Structure:
- Posts Index: 60TB (recent 6 months)
- Users Index: 20TB
- Hashtags Index: 10TB
- Locations Index: 10TB

Search Features:
- Full-text search
- Fuzzy matching
- Autocomplete (prefix search)
- Filters (date, location, user)
- Ranking by relevance and engagement

Event → Kafka → Notification Worker → Filter by Preferences →
Push Service (APNs/FCM) → Device

Batching:
- Group similar notifications (10 likes → "X and 9 others liked")
- Delay non-urgent notifications (5 minutes)
- Send digest for high-volume users

Collaborative Filtering:
- Find similar users based on follow graph
- Recommend users followed by similar users

Content-Based Filtering:
- Analyze user's liked posts
- Recommend similar content

Hybrid Approach:
- Combine collaborative and content-based
- Use ML model to weight signals
- Apply business rules (diversity, freshness)

Features:
- User engagement history
- Follow graph
- Content preferences (hashtags, locations)
- Demographic information
- Time of day, day of week

1. User selects photo in app
2. App requests upload URL from Upload Service
3. Upload Service generates pre-signed S3 URL
4. App uploads photo directly to S3
5. S3 triggers SNS notification
6. Media Processing Service picks up job
7. Process: Resize, compress, generate thumbnails
8. Store processed images in S3
9. Update metadata in database
10. Warm CDN cache
11. Publish event to Kafka
12. Fan-out Service distributes to followers
13. Notification Service sends notifications
14. Return success to user

1. User opens app and requests feed
2. API Gateway authenticates request
3. Feed Service checks cache (Redis)
4. If cache hit: Return cached feed
5. If cache miss:
   a. Get list of users they follow
   b. Fetch recent posts from Timeline DB
   c. Merge celebrity posts (pull model)
   d. Fetch post metadata and media URLs
   e. Rank posts using ML model
   f. Apply business rules
   g. Cache result (TTL: 5 minutes)
6. Return feed to client
7. Client fetches media from CDN