Design Tinder (Matching System)

-- Persist every swipe before relying on Redis match state
-- requestHash is SHA-256 over the canonical request payload
START TRANSACTION;

INSERT INTO swipe_history (request_id, request_hash, user_id, target_user_id, action, created_at)
VALUES (:requestId, :requestHash, :userId, :targetUserId, :action, NOW())
ON DUPLICATE KEY UPDATE request_id = request_id;

-- Read the existing row for this user and request ID.
SELECT request_hash, swipe_id, target_user_id, action, response_status, match_id, matched_at, created_at, undone_at
FROM swipe_history
WHERE user_id = :userId AND request_id = :requestId
FOR UPDATE;

-- If the request ID already exists, the stored request_hash must equal :requestHash.
-- Return the persisted response fields for an identical finalized retry and HTTP 409 Conflict for a payload mismatch.
-- A newly detected match fills response_status=1, match_id, and matched_at in the same relational transaction as the canonical match and outbox event.
-- A completed non-match fills response_status=0 so a retry cannot change its historical result merely because a later swipe created a match.
-- After the Redis script returns 0, finalize the request result atomically:
UPDATE swipe_history
SET response_status = 0
WHERE user_id = :userId AND request_id = :requestId AND response_status IS NULL;

COMMIT;

-- KEYS[1]: match_pair:{min_user_id:max_user_id}
-- ARGV: [1] current_field, [2] request_id
-- The full normalized pair is the Redis Cluster hash tag, so all state for the pair stays on one slot.
-- Durable swipe history is persisted before this fast-path cache mutation.
local pair_key = KEYS[1]
local current_field = ARGV[1]
local request_id = ARGV[2]
local request_field = 'request:' .. request_id

-- Reject an already-processed request without changing state
if redis.call('HEXISTS', pair_key, request_field) == 1 then
  return 2
end

local other_field = 'right_a'
if current_field == 'right_a' then
  other_field = 'right_b'
end

-- Check whether the other side has already liked this pair
local already_liked = redis.call('HGET', pair_key, other_field)

-- Record the current user's right swipe
redis.call('HSET', pair_key, current_field, '1')
redis.call('HSET', pair_key, request_field, 'processed')
redis.call('EXPIRE', pair_key, 2592000)

if already_liked == '1' then
  -- Mutual match confirmed atomically. Durable match persistence follows idempotently.
  return 1
end

-- Recorded right swipe, but no mutual match yet
return 0

-- Idempotent match insertion using normalized pair IDs
-- Application code guarantees user_id_1 < user_id_2 and the database CHECK enforces it
START TRANSACTION;

INSERT INTO matches (user_id_1, user_id_2, matched_at)
VALUES (LEAST(:userA, :userB), GREATEST(:userA, :userB), NOW())
ON DUPLICATE KEY UPDATE matched_at = matched_at;

UPDATE swipe_history
SET response_status = 1,
    match_id = (SELECT match_id FROM matches WHERE user_id_1 = LEAST(:userA, :userB) AND user_id_2 = GREATEST(:userA, :userB)),
    matched_at = (SELECT matched_at FROM matches WHERE user_id_1 = LEAST(:userA, :userB) AND user_id_2 = GREATEST(:userA, :userB))
WHERE user_id = :currentUserId AND request_id = :requestId;

INSERT INTO match_outbox (match_id, event_type, event_key, created_at)
SELECT match_id, 'MATCH_CREATED', CONCAT(LEAST(:userA, :userB), ':', GREATEST(:userA, :userB)), NOW()
FROM matches
WHERE user_id_1 = LEAST(:userA, :userB)
  AND user_id_2 = GREATEST(:userA, :userB)
ON DUPLICATE KEY UPDATE event_type = event_type;

COMMIT;

# Add a target profile to the current bounded Bloom filter bucket
BF.ADD swiped_bf:{user_id}:{bucket} {target_user_id}

# Check the active Bloom filter bucket before adding a candidate to the discovery deck
BF.EXISTS swiped_bf:{user_id}:{bucket} {candidate_id}

# Bulk membership check for a candidate batch within one bucket
BF.MEXISTS swiped_bf:{user_id}:{bucket} {candidate_id_1} {candidate_id_2} {candidate_id_3}

# Rotate or chain additional buckets as history grows so each filter stays near its design capacity.

# Record an active Super Like for the recipient
ZADD super_likes:{target_user_id} {expiry_timestamp} {sender_user_id}

# Remove expired or consumed Super Likes during deck generation
ZREMRANGEBYSCORE super_likes:{target_user_id} -inf {current_timestamp}

# Fetch active Super Likes whose expiry has not passed
ZRANGEBYSCORE super_likes:{target_user_id} {current_timestamp} +inf LIMIT 0 10

# Set active boost TTL flag for 30 minutes (1800 seconds)
SET boost:{user_id} {expiry_timestamp} EX 1800

# Store boost expiry as the sorted-set score so expired boosts can be removed
ZADD boosted_users:{geohash_prefix} {expiry_timestamp} {user_id}

# Remove expired boosts before selecting active candidates
ZREMRANGEBYSCORE boosted_users:{geohash_prefix} -inf {current_timestamp}

# Retrieve currently active boosted candidates in the target geohash cell
ZRANGEBYSCORE boosted_users:{geohash_prefix} {current_timestamp} +inf LIMIT 0 10

boost_delivery_pipeline:
  candidate_assembly:
    step_1: "Remove expired boosts, then fetch active boosted users in the local geohash cell via ZRANGEBYSCORE"
    step_2: "Retrieve normal ranked candidate pool via geospatial filter and Elo scoring"
    step_3: "Prefer roughly 1 boosted profile per 5 organic profiles when eligible candidates are available"
    step_4: "Cap total boosted insertions at maximum 2 profiles per 200-card session deck"
  anti_abuse_controls:
    cooldown: "Maximum 1 boost per user every 12 hours with stacking disallowed"
    saturation_handling: "If active boosts exceed regional thresholds, dilute view delivery evenly"
  monetization_metrics:
    pricing: "Approximately $5 per 30-minute boost"
    projected_volume: "10M monthly boosts generating approximately $50M per month in revenue"