Design dating matches like Tinder

At 20 million people a day, a dating app records 23,148 swipes a second and builds 463 decks of nearby people a second. Its matching system does three jobs: it shows each person a deck of nearby profiles that suit both people’s settings, it records every swipe, and when two people have liked each other it creates a match that opens a chat. Decks are built ahead of time from a location index, with every setting checked in both directions, so each swipe is a small write.

The hard parts are correctness and safety: two likes that arrive at the same moment must create exactly one match, the distance a card shows must never give away where someone is, and a block must work at once. This case study sizes the app and follows each of its paths.

Both people’s settings must allow the pair

• Who may see whom? Each person sets the genders they want to see, an age range and a maximum distance of 2 to 100 km. A profile appears only when both people’s settings allow the pair.
• What makes a match? Two likes, in either order. A pass removes the profile from that person’s decks.
• After a match: both people hear about it within seconds and can chat; an unmatch ends the chat for both.
• Safety: blocks and reports, and distances shown only roughly.
• Out of scope: the chat itself (see chat delivery), payments and photo moderation.

Functionally, people report a position, fetch cards, like or pass, see their matches, and unmatch, block or report. The next card must be on the phone before the current one is swiped, so cards are fetched ahead and a page of them loads within 200 ms at the 99th percentile. An acknowledged swipe is never lost. A pair has at most one match, created within a second of the second like. An exact position never leaves the server, and a block applies on the next request.

Swipes are the biggest number; deck builds are the heaviest work

Each swipe is a few dozen bytes. The heavy work hides in the deck builds: the example below reads 18,499 people to fill one deck, so 463 builds a second check about 8.6 million candidates a second.

Six records, from a person’s square to the pair of two likes

• PUT /v1/me/location takes a latitude, a longitude and their accuracy; the server keeps only the person’s 1 km square and never returns it.
• GET /v1/deck?limit=25 returns cards: profile id, first name, age, photos and a label such as “4 km away”.
• POST /v1/swipes takes the profile id, like or pass, and a swipe id made by the app, so a retry is stored once; it answers whether the swipe made a match.
• GET /v1/matches, DELETE /v1/matches/{id}, POST /v1/blocks and POST /v1/reports complete the API.

Decks are built ahead, so a swipe is one small write

Position. The location service keeps only the centre of the person’s 1 km square and files them under a 4 km cell of the cell index. Deck build. Ahead of need, a deck builder reads the person’s cell and enough rings of cells around it to cover their maximum distance, applies every filter in both directions, drops past swipes and blocks, ranks the rest and writes the next 100 ids to the deck cache. Serve. The app fetches 25 cards at a time; the deck service fills them in from profiles, checks blocks again and turns distances into labels. Swipe. Every swipe goes to the swipe log, which feeds the swipe history, kept by the person who swiped. A like also updates the pair record of the two people, on the shardshard: One of several databases that together hold a group's data, each with its own share of the rows, such as the accounts of one set of customers and everything that belongs to them. More in “First-hand case: how MySmartCoPilot is built” the pair’s key picks, in one transaction. Match. If that transaction finds the other like already there, it creates the match, the reply says “It’s a match”, and the other person gets a notification. Follow one like through those steps:

The example builds one deck for a woman of 29 with a maximum distance of 8 km, among 40,000 synthetic people:

// One person's deck, built the way a deck builder does it: read the index cells around her, keep the people whose
// settings and hers both allow the pair, drop anyone she swiped or blocked, rank, and label distances roughly.
// 40,000 synthetic people live on a flat 60 km square measured in kilometres; a seeded generator makes them, so every
// run prints the same.
const INDEX_KM = 4; // the cell index groups people into 4 km squares
const SNAP_KM = 1; // positions are kept only as the centre of a 1 km square
const DECK_SIZE = 100;

function generator(seed) {
  const imul = Math.imul;
  return () => {
    seed = (seed + 0x6d2b79f5) | 0;
    let t = imul(seed ^ (seed >>> 15), 1 | seed);
    t = (t + imul(t ^ (t >>> 7), 61 | t)) ^ t;
    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
  };
}
const rand = generator(4111);
const pick = (items) => items[Math.floor(rand() * items.length)];
const WANTS_OF_W = ['M', 'M', 'M', 'M', 'M', 'M', 'M', 'M', 'W', 'MWN']; // mostly men, some women, a few anyone
const WANTS_OF_M = ['W', 'W', 'W', 'W', 'W', 'W', 'W', 'W', 'M', 'MWN'];
const MAX_KMS = [5, 10, 10, 15, 15, 25, 40];
const bell = (spread) => (rand() + rand() + rand() + rand() - 2) * spread; // a bump around 0, no Math.log needed

const snap = (v) => (Math.floor(v / SNAP_KM) + 0.5) * SNAP_KM;
const cellOf = (x, y) => `${Math.floor(x / INDEX_KM)},${Math.floor(y / INDEX_KM)}`;
const km = (a, b) => Math.sqrt((a.x - b.x) ** 2 + (a.y - b.y) ** 2);
const n = (v) => String(v).replace(/\B(?=(\d{3})+(?!\d))/g, ','); // 18460 -> 18,460

// People: most live in the city around (0, 0), the rest anywhere in the square.
const people = [];
for (let id = 1; id <= 40000; id++) {
  const inCity = rand() < 0.75;
  const x = inCity ? bell(14) : (rand() - 0.5) * 60;
  const y = inCity ? bell(14) : (rand() - 0.5) * 60;
  const gender = rand() < 0.47 ? 'W' : rand() < 0.95 ? 'M' : 'N';
  const wants = gender === 'W' ? pick(WANTS_OF_W) : gender === 'M' ? pick(WANTS_OF_M) : 'MWN';
  const age = 18 + Math.floor(32 * Math.min(rand(), rand()));
  people.push({
    id, age, gender, wants,
    ageMin: Math.max(18, age - 2 - Math.floor(rand() * 6)), ageMax: age + 2 + Math.floor(rand() * 9),
    maxKm: pick(MAX_KMS), hoursAgo: Math.floor(rand() * 72),
    x: snap(x), y: snap(y), // what the location service keeps: never the exact position
  });
}
const index = new Map(); // cell -> ids of the people active there in the last 3 days
for (const p of people) {
  const c = cellOf(p.x, p.y);
  if (!index.has(c)) index.set(c, []);
  index.get(c).push(p.id);
}
const byId = (id) => people[id - 1];

const her = { id: 0, age: 29, gender: 'W', wants: 'M', ageMin: 27, ageMax: 35, maxKm: 8, x: snap(1.3), y: snap(-0.6) };
const swiped = new Set(Array.from({ length: 6000 }, () => 1 + Math.floor(rand() * 40000)));
const blocked = new Set([2286, 31407]);

// 1. Read the cells: hers and enough rings of neighbours to cover her maximum distance.
const rings = Math.ceil(her.maxKm / INDEX_KM);
const [cx, cy] = cellOf(her.x, her.y).split(',').map(Number);
let read = [];
for (let dx = -rings; dx <= rings; dx++) for (let dy = -rings; dy <= rings; dy++) read.push(...(index.get(`${cx + dx},${cy + dy}`) ?? []));
const cells = (2 * rings + 1) ** 2;
console.log(`cells read: ${cells} (her ${INDEX_KM} km cell and ${rings} rings around it), people in them: ${n(read.length)}`);

// 2. Filter: every rule holds in both directions, so neither person sees someone who could never see them.
const steps = [
  ['within her 8 km', (p) => km(her, p) <= her.maxKm],
  ['genders wanted both ways', (p) => her.wants.includes(p.gender) && p.wants.includes(her.gender)],
  ['ages wanted both ways', (p) => p.age >= her.ageMin && p.age <= her.ageMax && her.age >= p.ageMin && her.age <= p.ageMax],
  ['within their own distance', (p) => km(her, p) <= p.maxKm],
  ['not swiped or blocked', (p) => !swiped.has(p.id) && !blocked.has(p.id)],
];
let left = read.map(byId);
for (const [name, keep] of steps) {
  left = left.filter(keep);
  console.log(`  ${name.padEnd(27)} ${n(left.length).padStart(6)}`);
}

// 3. Rank: near and recently active first (6 hours away from the app count like 1 km more); keep a deck of 100.
const score = (p) => km(her, p) + p.hoursAgo / 6;
const deck = left.slice().sort((a, b) => score(a) - score(b) || a.id - b.id).slice(0, DECK_SIZE);
const label = (p) => `${Math.max(1, Math.round(km(her, p)))} km away`; // whole km between 1 km squares
console.log(`\ndeck: ${deck.length} of ${n(left.length)} eligible people; the first 6 cards:`);
for (const p of deck.slice(0, 6)) console.log(`  #${String(p.id).padStart(5)}  age ${p.age}  ${label(p).padEnd(10)}  active ${p.hoursAgo} h ago`);
const shown = new Map();
for (const p of deck) shown.set(label(p), (shown.get(label(p)) ?? 0) + 1);
console.log(`the deck's distance labels: ${[...shown].sort((a, b) => parseInt(a[0]) - parseInt(b[0])).map(([l, c]) => `${c} × ${l.replace(' away', '')}`).join(', ')}`);

// 4. Check: a scan of all 40,000 people finds exactly the same eligible set, so the cells missed no one.
const scan = people.filter((p) => steps.every(([, keep]) => keep(p)));
const same = scan.length === left.length && scan.every((p) => left.includes(p));
console.log(`\nfull scan of ${n(people.length)} people: ${n(scan.length)} eligible, ${same ? 'the same people' : 'DIFFERENT people'}; the cells held ${(100 * read.length / people.length).toFixed(1)} % of everyone`);

cells read: 25 (her 4 km cell and 2 rings around it), people in them: 18,499
  within her 8 km             11,283
  genders wanted both ways     5,127
  ages wanted both ways        1,397
  within their own distance    1,310
  not swiped or blocked        1,138

deck: 100 of 1,138 eligible people; the first 6 cards:
  #25031  age 27  1 km away   active 0 h ago
  #32687  age 28  1 km away   active 1 h ago
  #19066  age 30  1 km away   active 0 h ago
  #21023  age 30  1 km away   active 0 h ago
  # 6503  age 27  1 km away   active 3 h ago
  #  439  age 29  1 km away   active 5 h ago
the deck's distance labels: 25 × 1 km, 22 × 2 km, 19 × 3 km, 21 × 4 km, 13 × 5 km

full scan of 40,000 people: 1,138 eligible, the same people; the cells held 46.2 % of everyone

The 25 cells held 18,499 people, and the filters left 1,138. The two-way rules did most of the work: 5,127 men within 8 km want women, but only 1,397 of them are in her age range and also want someone of 29. A scan of all 40,000 people finds the same 1,138, so reading cells missed no one. The labels are whole kilometres between square centres, from 1 to 5 km.

Practise: filter a deck in both directions

Write the filter a deck builder runs on every candidate:

def eligible(viewer, candidate, km):
    """True when the candidate may appear in the viewer's deck; km is the distance between their squares."""
    # Replace this line with your code.
    return True


def build_deck(viewer, candidates, swiped, blocked, size):
    """The ids of the viewer's deck from (person, km) pairs: eligible, not swiped or blocked, best first."""
    # Replace this line with your code.
    return [person["id"] for person, km in candidates][:size]

from deck import build_deck, eligible

HER = {"id": 1, "age": 29, "gender": "W", "wants": "M", "age_min": 27, "age_max": 35, "max_km": 8, "hours_ago": 0}


def person(id, **changes):
    base = {"id": id, "age": 30, "gender": "M", "wants": "W", "age_min": 25, "age_max": 34, "max_km": 15, "hours_ago": 3}
    base.update(changes)
    return base


def test_a_good_pair_is_eligible():
    """both people's settings accept each other"""
    assert eligible(HER, person(2), 3) is True


def test_genders_both_ways():
    """she wants men, and the man must also want women"""
    assert eligible(HER, person(2, gender="W", wants="W"), 3) is False
    assert eligible(HER, person(2, wants="M"), 3) is False
    assert eligible(HER, person(2, wants="MWN"), 3) is True


def test_ages_both_ways_ends_included():
    """her range is 27 to 35, and her age 29 must be in his range"""
    assert eligible(HER, person(2, age=27), 3) is True
    assert eligible(HER, person(2, age=35), 3) is True
    assert eligible(HER, person(2, age=26), 3) is False
    assert eligible(HER, person(2, age=36), 3) is False
    assert eligible(HER, person(2, age_min=29), 3) is True
    assert eligible(HER, person(2, age_max=29), 3) is True
    assert eligible(HER, person(2, age_min=30), 3) is False
    assert eligible(HER, person(2, age_max=28), 3) is False


def test_distance_within_both_limits():
    """at most her 8 km and at most his own maximum"""
    assert eligible(HER, person(2), 8) is True
    assert eligible(HER, person(2), 9) is False
    assert eligible(HER, person(2, max_km=5), 5) is True
    assert eligible(HER, person(2, max_km=5), 6) is False


def test_never_yourself():
    """the viewer is not a candidate in her own deck"""
    assert eligible(HER, dict(HER, gender="M", wants="W"), 0) is False


def test_deck_filters_swiped_and_blocked():
    """swiped and blocked ids never come back"""
    candidates = [(person(2), 3), (person(3), 2), (person(4), 1), (person(5, age=40), 1)]
    assert build_deck(HER, candidates, swiped={3}, blocked={4}, size=10) == [2]


def test_deck_order_and_size():
    """nearest first, then the most recently active, then the smaller id; at most size cards"""
    candidates = [
        (person(10, hours_ago=1), 4),
        (person(11, hours_ago=9), 2),
        (person(12, hours_ago=2), 2),
        (person(13, hours_ago=2), 2),
        (person(14, hours_ago=0), 7),
    ]
    assert build_deck(HER, candidates, swiped=set(), blocked=set(), size=10) == [12, 13, 11, 10, 14]
    assert build_deck(HER, candidates, swiped=set(), blocked=set(), size=3) == [12, 13, 11]

Then practise, weakest idea first:

The deep dives this design must answer

A round then probes these questions:

• Two likes at once: the like and the check share one record per pair, so exactly one of two simultaneous likes creates the match.
• Crowded cities: a city-centre cell holds far more people than a rural one, which changes how a build reads it.
• Fresh decks: a deck is rebuilt when it runs low, when the person moves or changes settings, and when it ages.
• Past swipes: a Bloom filterBloom filter: A small bit array built from a set of keys that answers "definitely not here" or "maybe here", never a false no. LSM engines keep one per file to skip the files that lack a key. More in “Storage engines: B-trees vs LSM-trees” of each person’s swiped ids keeps profiles from coming back cheaply.
• Location privacy: distances come from coarse squares and are rounded, so the most anyone learns is a square.
• Blocks: they are checked when cards are served and messages sent, not only when decks are built.
• Scale: the bottlenecks move at 10 × and 100 × the swipes.

Exactly one match for two likes, reproduced Pro: opens with a Pro, Premium or Ultimate pass

Deck builds in crowded cities, measured and sized Pro: opens with a Pro, Premium or Ultimate pass

Location privacy, safety, failure drills and the level rubric Pro: opens with a Pro, Premium or Ultimate pass

Interview questions

Choose your opening move for each brief:

Key takeaways

• Build decks ahead of time from the cells around a person, with every filter applied in both directions.
• A deck build reads thousands of people to keep a hundred: that read, not the swipe rate, is the heavy work.
• A swipe is a small write to a log; a like also updates one record for the pair.
• Keep only coarse positions: 1 km squares, and distances in whole kilometres.