Engineering

• Learned Indexes: When Models Replace B‑Trees · 2025-10-04

  A practitioner's guide to learned indexes: how they work, when they beat classic data structures, and what it takes to ship them without getting paged.

• The 100‑Microsecond Rule: Why Tail Latency Eats Your Throughput (and How to Fight Back) · 2025-10-04

  A field guide to taming P99 in modern systems—from queueing math to NIC interrupts, from hedged requests to adaptive concurrency. Practical patterns, pitfalls, and a blueprint you can apply this week.

• Auditing the Algorithm: Building a Responsible AI Pipeline That Scales · 2025-04-05

  How we operationalized responsible AI with automated audits, governance rituals, and transparent reporting.

• Scheduling: Trading Latency for Throughput (and Back Again) · 2025-02-12

  Queue disciplines, work stealing, and CPU affinity: how scheduler choices shape p50/p99, and when to bias for one over the other.

• Seeing in the Dark: Observability for Edge AI Fleets · 2024-08-16

  A practitioner's guide to instrumenting, monitoring, and debugging machine learning models running at the edge.

• Countdown to Quantum: Migrating an Enterprise to Post-Quantum Cryptography · 2024-01-29

  Practical lessons from a multi-year effort to adopt quantum-safe cryptography without breaking production.

• Sealing the Supply Chain: Zero-Trust Build Pipelines That Scale · 2023-10-08

  An engineer’s map for rebuilding the software supply chain around zero-trust principles without stopping delivery.

• Reverse Indexing and Inverted Files: How Search Engines Fly · 2023-07-19

  Tokenization, postings lists, skip pointers, and WAND: a tour of the data structures that make full‑text search fast.

• Keeping the Model Awake: Building a Self-Healing ML Inference Platform · 2023-02-14

  A field report on taming production machine learning inference with proactive healing, adaptive scaling, and human empathy.

• Timeouts, Retries, and Idempotency Keys: A Practical Guide · 2022-09-08

  Make your distributed calls safe under partial failure. How to budget timeouts, avoid retry storms, and use idempotency keys without shooting yourself in the foot.

• Teaching GraphQL to Cache at the Edge · 2022-09-03

  A deep dive into making GraphQL play nicely with edge caches without breaking declarative APIs.

• Instrumenting Without Spying: Privacy-Preserving Telemetry at Scale · 2021-05-27

  How we rebuilt our telemetry pipeline to respect user privacy without sacrificing insight.

• Cache‑Friendly Data Layouts: AoS vs. SoA (and the Hybrid In‑Between) · 2021-03-18

  How memory layout choices shape the performance of your hot loops. A practical guide to arrays‑of‑structs, struct‑of‑arrays, and hybrid layouts across CPUs and GPUs.

• Raft Fast‑Commit and PreVote in Practice · 2020-11-09

  What fast‑commit and PreVote actually change in Raft, how they affect availability during leader changes, and where the footguns are.

• Merkle Trees and Content‑Addressable Storage · 2020-08-17

  From Git to distributed object stores: how Merkle DAGs enable integrity, deduplication, and efficient sync.

• Tuning the Dial: Adaptive Consistency at Planet Scale · 2020-03-11

  Inside the engineering of databases that adjust consistency on the fly without breaking user trust.

• When Data Centers Learned to Sleep: Energy-Aware Scheduling in Practice · 2019-07-19

  An engineer’s chronicle of how hyperscale fleets embraced energy-aware scheduling without sacrificing latency or trust.

• Speculative Prefetchers: Designing Memory Systems That Read the Future · 2019-02-14

  A field guide to building and validating speculative memory prefetchers that anticipate demand in modern CPUs and data platforms.