Failure Recovery Patterns for Low-Latency Candidate Retrieval and Reranking A developer outlined a failure-recovery pattern for low-latency candidate retrieval and reranking that makes lexical search the authoritative fallback, bounds each optional stage (vector retrieval, reranking) with its own deadline inside a 250 ms end-to-end budget, and returns a typed result envelope recording which path served the request and which stages timed out. The approach keeps vector and reranker stages as quality add-ons that never own correctness, defers retries to an asynchronous queue, and recommends tracking recall@50, nDCG@10, p95 latency, timeout rate and per-path share before adopting the design. Short answer: keep candidate retrieval useful when a reranker, index, or embedding service fails by making lexical search the authoritative fallback, bounding every optional stage with a deadline, and logging which path actually served the request. The decision is retrieval quality versus latency, and recovery has to preserve that contract. I learned to treat failure recovery as part of ranking design, not an exception handler added after launch. A recruiter searching for “senior iOS engineer, payments” can tolerate a less polished ordering for a few seconds; an empty result page is much harder to explain. The same pattern applies to an e-commerce catalog reranker: the system must return plausible items while an expensive model is unavailable. The simple approach is one request that calls vector retrieval, metadata filters, a cross-encoder reranker, and an LLM explanation in sequence. It looks tidy on a diagram. It also lets the slowest dependency decide whether a recruiter sees anything. My test harness uses a 250 ms end-to-end budget. Stage one runs a lexical query against the candidate index; stage two may add vector results; stage three reranks only the merged top 100. Explanations are asynchronous. If stage two misses its 70 ms budget, the merge continues with lexical hits. If stage three misses 110 ms, the original order remains valid. Three words matter: return something useful. Before copying this shape, measure recall@50, nDCG@10, p95 latency, timeout rate, and the percentage of requests served by each path. A faster fallback that hides a 20% recall loss is not a recovery win. Your mileage may vary because corpus size, language, and filter selectivity change those numbers. Use independent budgets and an explicit result envelope. A timeout should become a typed event, not an unstructured log line. This TypeScript sketch keeps the policy in one place so a UI can show a result set without guessing why a stage was skipped. type RetrievalPath = "lexical" | "hybrid" | "reranked"; type CandidateHit = { id: string; score: number; source: "lexical" | "vector" | "reranker"; }; type SearchResponse = { hits: CandidateHit ; path: RetrievalPath; timedOutStages: string ; }; async function searchCandidates query: string, deadlineMs = 250 : Promise