perf

Perf — Performance Review

Process

1. Identify performance-sensitive code paths from the diff (loops, queries, rendering, batch ops)
2. Run the Checklist below, marking each item as pass, fail, or N/A with reason
3. For each failure, cite the file and line number with a one-line fix hint
4. Report findings using the Evidence Required section

When to Trigger

• Database queries inside loops
• Large data set processing
• Rendering or UI update logic
• API endpoint that could receive high traffic
• File I/O in hot paths

Checklist

Database

• No N+1 queries (use JOIN, eager loading, or batch) — N+1 queries cause latency to scale linearly with row count, turning a 1ms query into seconds under load.
• Indexes exist for frequently queried columns — without indexes, the database performs full table scans, collapsing read throughput.
• Pagination for large result sets — fetching all rows at once exhausts memory and increases response time for every consumer.
• Connection pooling configured — opening a new connection per request adds network round-trip overhead and can exhaust database connection limits.

Memory

• No unbounded arrays or caches growing indefinitely — unbounded growth causes gradual memory exhaustion and eventual OOM kills with no warning.
• Event listeners properly removed / unsubscribed — leaked listeners hold references to their context, preventing garbage collection of entire object graphs.
• Large objects released after use — holding references to large payloads keeps them in the heap, increasing GC pressure and pause times.
• Streams used for large file processing (not loading entire file) — loading a multi-GB file into RAM blocks other allocations and risks crashing the process.

Computation

• Expensive calculations memoized where appropriate — recomputing pure results on every call wastes CPU cycles that compound in hot paths.
• No redundant re-renders (React: useMemo, useCallback) — unnecessary re-renders cascade through the component tree, causing layout thrash and dropped frames.
• Async operations don't block the main thread — blocking the main thread stalls all concurrent requests, degrading throughput for every user.
• Debounce/throttle on frequent events (scroll, input) — unthrottled handlers fire hundreds of times per second, overwhelming the event loop.