class AutoScaling:
    services = {
        'order_service': {'min': 20, 'max': 100, 'target_cpu': 70},
        'location_service': {'min': 30, 'max': 150, 'target_cpu': 70},
        'matching_service': {'min': 15, 'max': 80, 'target_cpu': 75}
    }

-- Sharding by order_id
CREATE TABLE orders_shard_0 PARTITION OF orders
FOR VALUES WITH (MODULUS 16, REMAINDER 0);

-- Time-based partitioning
CREATE TABLE orders_2024_01 PARTITION OF orders
FOR VALUES FROM ('2024-01-01') TO ('2024-02-01');

-- Read replicas
CREATE REPLICA orders_replica_1 FROM orders_primary;

class CacheHierarchy:
    # L1: Local cache (100ms)
    # L2: Redis cluster (5ms)
    # L3: Database (50ms)
    
    async def get_restaurant_menu(self, restaurant_id):
        # Check L1
        if menu := self.local_cache.get(f'menu:{restaurant_id}'):
            return menu
        
        # Check L2
        if menu := await self.redis.get(f'menu:{restaurant_id}'):
            self.local_cache.set(f'menu:{restaurant_id}', menu, ttl=300)
            return menu
        
        # Query L3
        menu = await self.db.get_menu(restaurant_id)
        await self.redis.setex(f'menu:{restaurant_id}', 3600, menu)
        return menu

class LocationScaling:
    # Use Redis Geo for spatial queries
    async def update_location(self, driver_id, lat, lon):
        await self.redis.geoadd('drivers', lon, lat, driver_id)
    
    async def find_nearby(self, lat, lon, radius_km):
        return await self.redis.georadius('drivers', lon, lat, radius_km, unit='km')

kafka:
  topics:
    order_events:
      partitions: 24
      replication: 3
    location_updates:
      partitions: 48
      replication: 3

load_balancer:
  algorithm: least_connections
  health_check:
    path: /health
    interval: 10s
  sticky_sessions: true

class MultiRegion:
    regions = {
        'us_east': {'primary': True, 'latency_target': '50ms'},
        'us_west': {'primary': False, 'latency_target': '50ms'},
        'eu_west': {'primary': False, 'latency_target': '100ms'}
    }