⚡ Performance Optimization

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

Day 1-2: Profiling & Analysis
├── Application profiling (APM)
├── Database slow query analysis
├── Infrastructure metrics review
└── Baseline measurements

Day 3-5: Quick Wins
├── Add missing indexes
├── Fix N+1 queries
├── Enable obvious caching
└── Configuration tuning

Week 2: Deeper Optimization
├── Query rewrites
├── Caching strategy
├── Async processing
└── Architecture changes

Ongoing: Monitoring
├── Performance dashboards
├── Alerting setup
├── Regression prevention
└── Capacity planning

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

-- Step 1: Find slow queries
SELECT 
    query,
    calls,
    mean_time,
    total_time
FROM pg_stat_statements
ORDER BY total_time DESC
LIMIT 10;

-- Step 2: Analyze specific query
EXPLAIN (ANALYZE, BUFFERS) 
SELECT * FROM orders 
WHERE status = 'pending' 
ORDER BY created_at DESC;

-- Step 3: Add targeted index
CREATE INDEX CONCURRENTLY idx_orders_status_created 
ON orders(status, created_at DESC);

-- Step 4: Verify improvement
-- Re-run EXPLAIN to confirm index usage

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

from functools import lru_cache
import redis

# Layer 1: In-memory (process-local)
@lru_cache(maxsize=1000)
def get_config(key: str) -> Config:
    return db.query(Config).filter_by(key=key).first()

# Layer 2: Distributed (Redis)
class CachedProductService:
    def __init__(self, redis_client: redis.Redis):
        self.redis = redis_client
        self.ttl = 300  # 5 minutes
    
    def get_product(self, product_id: int) -> Product:
        cache_key = f"product:{product_id}"
        
        # Try cache first
        cached = self.redis.get(cache_key)
        if cached:
            return Product.parse_raw(cached)
        
        # Fetch from DB
        product = db.query(Product).get(product_id)
        
        # Cache for next time
        self.redis.setex(cache_key, self.ttl, product.json())
        
        return product

# Layer 3: CDN (for static content)
# Configure CloudFront/Cloudflare for static assets

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# Key metrics to track
PERFORMANCE_METRICS = {
    # Response times
    "api_latency_p50": "< 100ms",
    "api_latency_p95": "< 500ms",
    "api_latency_p99": "< 1000ms",
    
    # Database
    "db_query_time_avg": "< 50ms",
    "db_connections_active": "< 80% of pool",
    "slow_queries_per_hour": "< 10",
    
    # Infrastructure
    "cpu_utilization": "< 70%",
    "memory_utilization": "< 80%",
    "error_rate": "< 0.1%"
}