When does binary quantization beat Product Quantization as the production compression choice for a vector index?

**Binary quantization** stores each vector as a string of bits: one bit per dimension, set to 1 if that dimension is positive and 0 otherwise. A 1024-dim float32 vector (4096 bytes) becomes 128 bytes, a 32x compression. The payoff is speed. Distance between two binary vectors is the **Hamming distance**: the number of bits that differ. Modern CPUs compute this as one `popcount(a XOR b)` instruction per 64-bit chunk, dramatically faster than float multiplies. Product Quantization is a more sophisticated competitor. PQ splits each vector into chunks, learns a 256-entry codebook per chunk position, and stores one byte per chunk. PQ at 32 bytes per vector compresses 1024-dim float32 by 128x: more aggressive than binary quantization but slower per distance comparison. The modern winner depends on the embedding model. If the embedder was trained to be quantization friendly (Matryoshka representation learning, BGE-M3, voyage-binary), binary quantization holds recall at or above 95 percent of full precision. If the embedder is a generic model that does not survive the bit truncation, PQ is the safer pick.

**Binary quantization** wins when the embedding model was specifically designed to survive it. The catch is the model, not the database side. Mechanically, BQ is one bit per dimension: `1` if the float is positive, `0` if negative. A 1024-dim vector becomes 128 bytes. Distance is Hamming distance, computed via `popcount(a XOR b)`: a single CPU instruction over 64-bit chunks. That makes BQ both the most aggressive compression and the fastest distance computation of any production grade technique. The historical problem was recall. With ordinary embeddings, throwing away everything except the sign destroyed retrieval quality. PQ, which learns a 256-codeword codebook per sub-vector, preserved more information at the cost of being slower (table lookups per distance) and requiring an offline codebook training step. **What changed in 2024-2026 is the embedding side.** Matryoshka representation learning produces embeddings whose prefixes remain informative, and models like BGE-M3 and voyage-binary include binary aware fine-tuning that explicitly preserves sign only signal. With these models, binary quantization holds recall within 1-2 percent of full precision. The decision rule: quantization friendly embedding + cost sensitive RAG goes to BQ. Billion scale corpus with full precision recall demands goes to IVF-PQ. The other options in the question are distractors (corpus size, embedding dimension, blanket claims that PQ is dead) that conflate unrelated knobs.