Designing TikTok: Short-Form Video Platform

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

-- Pre-computed creator daily stats table (ClickHouse)
CREATE TABLE creator_daily_stats (
    creator_id UInt64,
    date Date,
    
    -- Engagement metrics
    total_views UInt64,
    total_likes UInt64,
    total_comments UInt64,
    total_shares UInt64,
    total_saves UInt64,
    
    -- Follower metrics
    new_followers UInt32,
    unfollows UInt32,
    net_follower_change Int32,
    
    -- Demographic breakdown (stored as maps for flexibility)
    views_by_country Map(String, UInt64),
    views_by_age_bracket Map(String, UInt64),
    views_by_gender Map(String, UInt64),
    
    -- Traffic source breakdown
    views_from_fyp UInt64,
    views_from_following UInt64,
    views_from_search UInt64,
    views_from_profile UInt64,
    views_from_sound UInt64,
    views_from_hashtag UInt64,
    
    -- Performance metrics
    avg_watch_time_seconds Float32,
    completion_rate Float32,
    
    PRIMARY KEY (creator_id, date)
) ENGINE = MergeTree()
PARTITION BY toYYYYMM(date)
ORDER BY (creator_id, date)
TTL date + INTERVAL 90 DAY DELETE;
 
-- Example: Get creator's 7-day overview (optimized query)
SELECT
    sum(total_views) as views_7d,
    sum(total_likes) as likes_7d,
    sum(new_followers) as new_followers_7d,
    avg(avg_watch_time_seconds) as avg_watch_time,
    avg(completion_rate) as avg_completion_rate
FROM creator_daily_stats
WHERE 
    creator_id = 12345
    AND date >= today() - 7
    AND date < today();
-- Query time: <10ms (reads 7 pre-aggregated rows)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

interface GiftTransaction {
  transaction_id: string;
  sender_id: string;
  receiver_id: string;
  live_stream_id: string;
  gift_id: string;
  coin_amount: number;
  diamond_amount: number;  // After TikTok's cut
  timestamp: number;
}
 
class GiftService {
  async sendGift(request: SendGiftRequest): Promise<GiftResult> {
    const { senderId, receiverId, liveStreamId, giftId } = request;
    
    // 1. Validate gift exists and is available
    const gift = await this.giftCatalog.get(giftId);
    if (!gift || !gift.available) {
      throw new ValidationError('Gift not available');
    }
    
    // 2. Check sender has sufficient coins (with lock)
    const senderWallet = await this.walletService.getWithLock(senderId);
    if (senderWallet.coinBalance < gift.coinCost) {
      throw new InsufficientFundsError();
    }
    
    // 3. Calculate diamond amount (receiver's share)
    const diamondAmount = Math.floor(gift.coinCost * 0.5);  // 50% to creator
    
    // 4. Create transaction record (idempotent)
    const transactionId = this.generateTransactionId(request);
    const existing = await this.checkExistingTransaction(transactionId);
    if (existing) {
      return existing;  // Idempotent return
    }
    
    // 5. Execute atomic transfer
    await this.executeAtomicTransfer({
      transactionId,
      from: { userId: senderId, type: 'coins', amount: gift.coinCost },
      to: { userId: receiverId, type: 'diamonds', amount: diamondAmount },
      metadata: { liveStreamId, giftId }
    });
    
    // 6. Emit gift event for live stream display
    await this.liveEventService.emit({
      type: 'gift_received',
      streamId: liveStreamId,
      gift: {
        senderId,
        senderName: await this.userService.getDisplayName(senderId),
        giftId,
        giftAnimationUrl: gift.animationUrl,
        coinValue: gift.coinCost
      }
    });
    
    // 7. Log for analytics and audit
    await this.auditLog.record({
      type: 'gift_transaction',
      transactionId,
      senderId,
      receiverId,
      amount: gift.coinCost,
      timestamp: Date.now()
    });
    
    return {
      success: true,
      transactionId,
      newBalance: senderWallet.coinBalance - gift.coinCost
    };
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

from dataclasses import dataclass
from enum import Enum
from typing import Optional
 
class CreatorTier(Enum):
    STANDARD = 'standard'
    ELIGIBLE = 'eligible'
    PROGRAM_MEMBER = 'program_member'
    RISING = 'rising'
    ESTABLISHED = 'established'
    PARTNER = 'partner'
 
@dataclass
class CreatorMetrics:
    follower_count: int
    views_30d: int
    avg_engagement_rate: float
    account_age_days: int
    active_strikes: int
    verified: bool
    country: str
    age: int
 
@dataclass
class EligibilityResult:
    current_tier: CreatorTier
    eligible_for_next: bool
    next_tier: Optional[CreatorTier]
    missing_requirements: list[str]
    monetization_enabled: bool
 
class EligibilityChecker:
    def __init__(self, program_config: dict):
        self.config = program_config
    
    def evaluate(self, metrics: CreatorMetrics) -> EligibilityResult:
        # Check for disqualifying conditions
        if metrics.active_strikes > 0:
            return EligibilityResult(
                current_tier=CreatorTier.STANDARD,
                eligible_for_next=False,
                next_tier=None,
                missing_requirements=['Account has active policy strikes'],
                monetization_enabled=False
            )
        
        # Determine current tier based on metrics
        current_tier = self._calculate_tier(metrics)
        
        # Check next tier eligibility
        next_tier, missing = self._check_next_tier(current_tier, metrics)
        
        # Monetization requires program member or above
        monetization_enabled = (
            current_tier.value >= CreatorTier.PROGRAM_MEMBER.value
            and metrics.age >= 18
            and metrics.country in self.config['monetization_countries']
        )
        
        return EligibilityResult(
            current_tier=current_tier,
            eligible_for_next=len(missing) == 0,
            next_tier=next_tier,
            missing_requirements=missing,
            monetization_enabled=monetization_enabled
        )
    
    def _calculate_tier(self, metrics: CreatorMetrics) -> CreatorTier:
        if metrics.verified and metrics.follower_count >= 5_000_000:
            return CreatorTier.PARTNER
        if metrics.follower_count >= 1_000_000:
            return CreatorTier.ESTABLISHED
        if metrics.follower_count >= 100_000 and metrics.avg_engagement_rate > 0.05:
            return CreatorTier.RISING
        if (metrics.follower_count >= 10_000 
            and metrics.views_30d >= 100_000 
            and metrics.age >= 18):
            return CreatorTier.PROGRAM_MEMBER
        if metrics.follower_count >= 1_000:
            return CreatorTier.ELIGIBLE
        return CreatorTier.STANDARD

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

interface ContentAppeal {
  appealId: string;
  creatorId: string;
  contentId: string;
  originalDecision: 'removed' | 'age_restricted' | 'demonetized';
  originalReason: string;
  appealText: string;
  submittedAt: Date;
  status: 'pending' | 'in_review' | 'upheld' | 'overturned';
  reviewedBy?: string;
  reviewedAt?: Date;
  reviewNotes?: string;
}
 
class AppealService {
  async submitAppeal(request: SubmitAppealRequest): Promise<ContentAppeal> {
    // 1. Validate appeal eligibility
    const content = await this.contentService.get(request.contentId);
    if (!content.appealable) {
      throw new AppealError('Content not eligible for appeal');
    }
    
    // 2. Check for existing appeal
    const existingAppeal = await this.findExistingAppeal(request.contentId);
    if (existingAppeal && existingAppeal.status !== 'overturned') {
      throw new AppealError('Appeal already submitted for this content');
    }
    
    // 3. Create appeal record
    const appeal: ContentAppeal = {
      appealId: generateId(),
      creatorId: request.creatorId,
      contentId: request.contentId,
      originalDecision: content.moderationDecision,
      originalReason: content.moderationReason,
      appealText: request.appealText,
      submittedAt: new Date(),
      status: 'pending'
    };
    
    await this.appealStore.save(appeal);
    
    // 4. Route to appropriate queue based on creator tier
    const creatorTier = await this.creatorService.getTier(request.creatorId);
    const priority = this.calculatePriority(creatorTier, content.viewCount);
    
    await this.reviewQueue.enqueue({
      appealId: appeal.appealId,
      priority,
      sla: this.getSLA(creatorTier)  // 24h for established, 7d for standard
    });
    
    // 5. Notify creator
    await this.notificationService.send({
      userId: request.creatorId,
      type: 'appeal_submitted',
      message: `Your appeal has been submitted. Expected review: ${this.getSLA(creatorTier)}`
    });
    
    return appeal;
  }
  
  async processAppealDecision(
    appealId: string, 
    decision: 'upheld' | 'overturned',
    reviewerId: string,
    notes: string
  ): Promise<void> {
    const appeal = await this.appealStore.get(appealId);
    
    // Update appeal record
    appeal.status = decision === 'overturned' ? 'overturned' : 'upheld';
    appeal.reviewedBy = reviewerId;
    appeal.reviewedAt = new Date();
    appeal.reviewNotes = notes;
    
    await this.appealStore.save(appeal);
    
    // If overturned, restore content
    if (decision === 'overturned') {
      await this.contentService.restore(appeal.contentId);
    }
    
    // Notify creator
    await this.notificationService.send({
      userId: appeal.creatorId,
      type: 'appeal_decision',
      message: decision === 'overturned' 
        ? 'Your appeal was successful. Content has been restored.'
        : 'Your appeal was reviewed. The original decision stands.'
    });
  }
}