Twitter/X

Redis Timeline Structure:

# Each user has his own timeline in Redis
# Key: timeline:{user_id}
#Value: Sorted Set (score = timestamp, member = tweet_id)

ZADD timeline:12345 1705234567 "tweet_abc123"
ZADD timeline:12345 1705234890 "tweet_def456"

# Retrieving the last 100 tweets
ZREVRANGE timeline:12345 0 99

# Timeline storage estimation:
#200M users × 800 tweets × 8 bytes = 1.28 TB
# With replication ×3 = ~4 TB Redis cluster

# Simplified Twitter Trending Score

def calculate_trend_score(topic, current_window):
    # Current velocity: tweets per minute in last 5 min
    current_count = count_in_window(topic, minutes=5)
    
    # Baseline: average tweets per 5-min over past 7 days
    baseline_count = get_baseline(topic, days=7)
    
    # Velocity ratio: how much faster than normal
    if baseline_count > 0:
        velocity_ratio = current_count / baseline_count
    else:
        velocity_ratio = current_count * 10  # New topic bonus
    
    # Recency weight: exponential decay
    recency_weight = sum(
        tweet.weight * exp(-lambda * (now - tweet.timestamp))
        for tweet in current_window.tweets
    )
    
    # Engagement boost
    engagement_score = (likes + retweets * 2 + replies * 3) / total_tweets
    
    # Final score
    score = velocity_ratio * recency_weight * (1 + log(engagement_score))
    
    # Spam/bot filtering
    if unique_users_ratio < 0.3:  # Too few unique users
        score *= 0.1  # Heavy penalty
    
    return score

Ranking Features:

# Core Tables

tweets {
    tweet_id: UUID (Snowflake ID)
    user_id: UUID
    content: VARCHAR(280)
    media_urls: JSON
    created_at: TIMESTAMP
    reply_to_tweet_id: UUID (nullable)
    retweet_of_id: UUID (nullable)
    quote_tweet_id: UUID (nullable)
    like_count: INT
    retweet_count: INT
    reply_count: INT
}

users {
    user_id: UUID
    username: VARCHAR(15)
    display_name: VARCHAR(50)
    bio: VARCHAR(160)
    follower_count: INT
    following_count: INT
    is_verified: BOOLEAN
    is_celebrity: BOOLEAN  # follower_count > 10K
    created_at: TIMESTAMP
}

follows {
    follower_id: UUID
    followee_id: UUID
    created_at: TIMESTAMP
    PRIMARY KEY (follower_id, followee_id)
}

# Denormalized for read performance
user_timelines (Redis Sorted Set)
    Key: timeline:{user_id}
    Score: tweet_timestamp
    Member: tweet_id

# Celebrity tweets (separate store)
celebrity_tweets (Redis Sorted Set)
    Key: celebrity:{user_id}
    Score: tweet_timestamp
    Member: tweet_id

# Snowflake ID Structure (64-bit)
┌────────────────────────────────────────────────────────────────┐
│ 1 bit │   41 bits timestamp   │ 10 bits │    12 bits          │
│unused │   (milliseconds)      │machine  │   sequence          │
│       │   since epoch         │   ID    │   number            │
└────────────────────────────────────────────────────────────────┘

# Properties:
# - Roughly sortable by time
# - No coordination needed
# - 4096 IDs per millisecond per machine
# - 69 years before overflow

# Example ID: 1605978261000000000
# Timestamp: 2020-11-21 12:31:01 UTC
# Machine: 42
# Sequence: 0

def generate_snowflake_id(machine_id, last_timestamp, sequence):
    timestamp = current_time_ms() - TWITTER_EPOCH
    
    if timestamp == last_timestamp:
        sequence = (sequence + 1) & 0xFFF  # 12 bits
        if sequence == 0:
            timestamp = wait_next_millis(last_timestamp)
    else:
        sequence = 0
    
    id = (timestamp << 22) | (machine_id << 12) | sequence
    return id, timestamp, sequence