REFACTORING PLAN

CURRENT BOTTLENECK
• Sequential database queries in loop
• New connection per request = 100ms overhead × 10 requests = 1000ms total
• Single-threaded execution blocks on I/O

ASYNC PATTERN: tokio with connection pool
1. Initialize connection pool at startup:
   let pool = sqlx::PgPool::connect(db_url).await?;
   pool.set_max_connections(20); // Match DB max_connections / threads

2. Spawn concurrent tasks:
   let handles: Vec<_> = requests.iter()
     .map(|req| {
       let pool = pool.clone(); // Arc handle, no move
       tokio::spawn(async move { query_db(&pool, req).await })
     }).collect();

3. Await all in parallel:
   let results = futures::future::try_join_all(handles).await?;

OWNERSHIP STRATEGY
→ Pool is Arc, cloning is cheap (reference count increment)
→ Request data is moved into spawned tasks (no shared mutable state)
→ Lifetime: async fn does not need explicit lifetimes if no borrowed references cross await
→ Error handling: .map_err() converts per-task errors, then collect() in parent

RESULT
Old: 1000ms for 10 queries
New: 100ms for 10 queries (limited by single slowest query + pool overhead)
Scaling: Pool size 20, 10 concurrent tasks = 2 batches through queue

TEST STRATEGY
• Unit: Mock database returns in 50ms
• Integration: Real DB, measure latency distribution
• Load: Drive 50 concurrent requests, track p95 latency and error rate