The Secretary Problem: Why You Should Reject the First 37%

Hire the best candidate, seeing them only once

N candidates apply for a job, one at a time, in random order. After each interview you must immediately accept or permanently reject that candidate - no going back. You can only ever rank the candidates you have seen against each other, not against the ones still to come. What strategy maximises your chance of picking the single best candidate out of all N? This is the secretary problem, the canonical example of optimal stopping theory, and its answer is startlingly clean: reject the first N/e candidates outright, no matter how good they look, then accept the first subsequent candidate who beats everyone seen so far.

Why a fixed 'look then leap' cutoff is optimal

Call the cutoff r: reject the first r-1 candidates unconditionally (the 'look' phase, used only to calibrate what 'good' means), then accept the first candidate after that who outranks every candidate seen so far. For this strategy to select the overall best candidate, two things must both happen: the true best candidate must arrive after position r, and no candidate in positions r to (their position minus 1) may have looked like a 'best so far' impostor before the real best arrives. Working through the probability of success for a given cutoff r out of N candidates gives:

P(success | cutoff r) = (r / N) · ∑_(k=r..N-1) 1/k

Treat x = r/N as a continuous fraction and let N grow large; the sum becomes an integral and the expression simplifies to P(x) ≈ -x·ln(x). Differentiating and setting the derivative to zero gives the maximiser x = 1/e, so the optimal cutoff is r ≈ N/e, and the resulting success probability at that cutoff is also exactly 1/e ≈ 0.368 - a rare case where the optimal strategy and the value it achieves converge to the same constant.

The surprising size of the answer

For N=100 candidates, the rule says: reject the first 37 outright (100/e ≈ 36.8), then hire the first candidate after that who beats everyone you have seen. This succeeds in identifying the single best candidate out of all 100 roughly 37% of the time - far better than the 1% you would get by guessing at random, and remarkably, this success probability barely changes as N grows: it converges to 1/e and stays there, whether N is 20 or 20,000. The strategy is scale-invariant in a genuinely useful sense: memorising 'reject the first 37%' works for any size of applicant pool.

Where the model breaks down in practice

The classical problem makes strong assumptions that rarely hold exactly: N is known in advance, candidates arrive in a uniformly random order, you can perfectly and immediately rank each new candidate against all previous ones, and you only care about winning outright - getting the second-best candidate is scored identically to getting the worst. Real hiring involves uncertain applicant pool size, correlated arrival order (strong candidates often cluster at graduation season), noisy evaluation, and the fact that a company usually prefers 'a very good hire, reliably' over 'the single best hire, rarely'. Variants of the problem relax each of these assumptions - the 'unknown N' case, the 'cardinal payoff' case where you are scored by the candidate's actual quality rather than a binary win/lose, and the 'multiple hires' case - and each has a different, generally less clean, optimal rule.

Monte Carlo verification

Rather than trust the calculus, the demo verifies it directly: for a chosen N, it runs many independent random permutations of ranked candidates, and for every possible cutoff r from 1 to N it counts how often the 'reject first r-1, then take the first record-breaker' rule lands the true best candidate. Plotting win rate against r/N produces a curve that peaks unmistakably near x=1/e≈0.368 with a peak height near 1/e≈0.368 too - both numbers, the optimal fraction to skip and the resulting odds of success, are the same constant, confirmed empirically rather than assumed.

for (let r = 1; r <= N; r++) {
  let wins = 0;
  for (let trial = 0; trial < TRIALS; trial++) {
    const perm = shuffledRanks(N);
    let bestSoFar = Math.max(...perm.slice(0, r - 1), 0);
    for (let i = r - 1; i < N; i++) {
      if (perm[i] > bestSoFar) { if (perm[i] === N) wins++; break; }
    }
  }
  winRate[r] = wins / TRIALS;
}

Frequently asked questions

Try it live

Everything above runs in your browser — open Secretary Problem and change the parameters while it is running. Nothing is installed, nothing is uploaded, the whole model lives in one tab.