Optimization Patterns

Purpose

Apply proven optimization techniques including caching, query optimization, and algorithm selection to improve application performance systematically.

When to Use

• After identifying bottlenecks through profiling
• Optimizing database-heavy operations
• Improving API response times
• Reducing resource consumption
• Scaling applications

Key Capabilities

1. Caching Strategies - Implement effective caching at multiple levels
2. Database Optimization - Improve query performance and reduce database load
3. Algorithm Optimization - Choose efficient algorithms and data structures

Approach

1. Identify Optimization Opportunities

   • Repeated expensive computations
   • Slow database queries
   • Inefficient algorithms
   • Unnecessary data transfers
   • Blocking operations

2. Apply Caching

   • Application cache: In-memory (Redis, Memcached)
   • Database cache: Query result caching
   • CDN cache: Static assets
   • Browser cache: HTTP caching headers
   • Computed values: Memoization

3. Optimize Database Access

   • Add indexes on filtered/joined columns
   • Use connection pooling
   • Implement pagination for large result sets
   • Batch operations (bulk insert/update)
   • Denormalize for read-heavy workloads
   • Use materialized views
   • Optimize N+1 queries with eager loading

4. Algorithm Improvements

   • Choose appropriate data structures (hash maps vs arrays)
   • Reduce time complexity (O(n²) → O(n log n))
   • Use lazy evaluation
   • Stream large datasets instead of loading all in memory
   • Parallelize independent operations

5. Reduce Latency

   • Minimize network round trips
   • Use async/non-blocking I/O
   • Compress data transfers
   • Connection pooling
   • Prefetch predictable data

Example

Context: Optimizing a slow dashboard that shows user statistics

Before Optimization:

def get_dashboard_data(user_id):
    # Multiple slow queries, no caching
    user = db.query("SELECT * FROM users WHERE id = ?", user_id)
    
    # O(n) query for each calculation
    total_orders = db.query(
        "SELECT COUNT(*) FROM orders WHERE user_id = ?", user_id
    )[0][0]
    
    revenue = db.query(
        "SELECT SUM(amount) FROM orders WHERE user_id = ?", user_id
    )[0][0]
    
    # Inefficient: loads all orders into memory
    recent_orders = db.query(
        "SELECT * FROM orders WHERE user_id = ? ORDER BY created_at DESC", 
        user_id
    )[:5]  # Only need 5, but fetches all
    
    return {
        'user': user,
        'stats': {
            'total_orders': total_orders,
            'total_revenue': revenue
        },
        'recent_orders': recent_orders
    }

# Performance: 450ms per request

After Optimization:

import redis
from functools import lru_cache

# Redis for distributed caching
cache = redis.Redis(host='localhost', port=6379, decode_responses=True)

def get_dashboard_data(user_id):
    # Check cache first
    cache_key = f"dashboard:{user_id}"
    cached = cache.get(cache_key)
    if cached:
        return json.loads(cached)
    
    # Single optimized query with indexes
    result = db.query("""
        SELECT 
            u.*,
            COUNT(o.id) as total_orders,
            COALESCE(SUM(o.amount), 0) as total_revenue
        FROM users u
        LEFT JOIN orders o ON o.user_id = u.id
        WHERE u.id = ?
        GROUP BY u.id
    """, user_id)[0]
    
    # Efficient query: LIMIT at database level
    recent_orders = db.query("""
        SELECT id, amount, created_at
        FROM orders
        WHERE user_id = ?
        ORDER BY created_at DESC
        LIMIT 5
    """, user_id)
    
    data = {
        'user': dict(result),
        'stats': {
            'total_orders': result['total_orders'],
            'total_revenue': result['total_revenue']
        },
        'recent_orders': recent_orders
    }
    
    # Cache for 5 minutes
    cache.setex(cache_key, 300, json.dumps(data))
    
    return data

# Performance: 12ms (cache hit) or 45ms (cache miss)
# 90% reduction in query time, 97% with cache

Database Indexes Added:

-- Support the JOIN efficiently
CREATE INDEX idx_orders_user_id ON orders(user_id);

-- Support ORDER BY + LIMIT
CREATE INDEX idx_orders_user_created ON orders(user_id, created_at DESC);

Optimization Techniques Applied:

1. Query reduction: 4 queries → 2 queries
2. Query combining: Used JOIN to get stats in one query
3. Caching: Redis cache with 5-minute TTL
4. Indexing: Added database indexes on filtered columns
5. Limit pushdown: LIMIT 5 at database, not application
6. Column selection: Only fetch needed columns

Best Practices

• ✅ Cache expensive computations and database queries
• ✅ Use appropriate cache invalidation strategies (TTL, event-based)
• ✅ Add database indexes on WHERE, JOIN, ORDER BY columns
• ✅ Paginate large result sets
• ✅ Use connection pooling for databases
• ✅ Batch database operations when possible
• ✅ Choose O(log n) or O(1) algorithms over O(n²)
• ✅ Measure before and after optimizations
• ✅ Use lazy evaluation for large datasets
• ✅ Compress data in transit when appropriate
• ❌ Avoid: Premature optimization
• ❌ Avoid: Over-caching (stale data issues)
• ❌ Avoid: Missing cache invalidation
• ❌ Avoid: Loading entire tables into memory