How the Winner Picker works

You upload a CSV file. The first row is the header, and every row after it is one entry. The file is read as a stream, one row at a time, so a list of two million entries is processed without ever loading it into memory. Nothing in your file is reordered, edited or de-duplicated. The exact file you upload is the file that gets attached to the result.

Every draw starts by building a fresh seed, and the seed is built from two independent sources mixed together:

• The NIST Randomness Beacon. The US National Institute of Standards and Technology publishes 64 bytes of randomness every 60 seconds, produced by quantum-physical processes rather than by any algorithm. Each value is cryptographically signed and chained to the one before it. We pull the current pulse at the moment your draw runs.
• Fresh entropy from the operating system, taken from the server's hardware entropy pool.

The two are combined with SHA-256 into the final seed. The beacon contributes physical randomness that nobody involved in the draw controls, and it stamps the seed in time: because a given pulse only comes into existence at a specific minute, a seed built from it cannot have existed before then. The local entropy is what keeps the seed itself private, since beacon values are published openly and a seed built from one alone would be reproducible by anyone.

If the beacon is ever unreachable, the draw falls back to operating system entropy alone rather than failing. The result page always states which source was used.

The seed drives a cryptographically secure pseudorandom number generator built on an AES-256 keystream. Every random number needed during the draw comes from it.

Numbers are produced with rejection sampling, which matters more than it sounds. The naive way to get a number in a range is to take a random value and apply a remainder operation, and that quietly makes some outcomes slightly more likely than others. Rejection sampling discards values that would fall into an uneven range and draws again, so every outcome is exactly as likely as every other.

Winners are selected with reservoir sampling, a classic algorithm that makes a uniform random selection in a single pass over the data, without needing to know the list size in advance.

The property that matters is this: when you draw k winners from n entries, every entry ends up with the same k/n probability of being selected. Position in the file makes no difference. The first row and the two-millionth row are treated identically.

Selecting a group of winners and ranking them are two different problems, and the second one is easy to get wrong.

Reservoir sampling produces a fair setof winners, but the order they happen to sit in reflects how they arrived while the file was being read. Using that order directly would let a row's position in your CSV influence which prize it wins. So once the winners are chosen, they are shuffled with a Fisher-Yates shuffle driven by the same generator before places are assigned. Each winner is then equally likely to land in any position.

Every completed draw is recorded with:

• a sequential drawing number
• the name given to it and the completion time in UTC
• the number of entries and the number of winners
• the full winners table, with every column from your file
• the original CSV, downloadable from the result page
• the random seed source used for that specific draw

The result lives on a permanent link you can share with anyone. Because the source list is attached, people can see the pool the winners came from, not just the names that came out of it.

A public draw can be opened by anyone with the link. A private draw sits behind a password you choose, and both the result and the source file stay locked until it is entered. A test draw runs the full process and shows you the winners, but saves nothing at all: no record, no link, no stored file. It exists only until you leave the page.