Essential Questions:
1. "What's the expected number of tenants (stores)?"
2. "What's the size distribution of tenants (small, medium, large)?"
3. "Do we need to support different pricing tiers with different resource limits?"
4. "Are there any tenants that require dedicated infrastructure?"
5. "What level of customization do tenants need?"

Follow-up Questions:
- "How do we handle tenant data isolation?"
- "What's our approach to noisy neighbor problems?"
- "Do we need to support tenant-specific compliance requirements?"

Critical Scale Questions:
1. "How many concurrent users per store on average?"
2. "What's the peak traffic multiplier during events like Black Friday?"
3. "How many products per store on average? Maximum?"
4. "What are our latency requirements for storefronts vs admin?"
5. "What's the expected order volume per second across all stores?"

Performance Clarifications:
- "Can we use eventual consistency for some operations?"
- "What's acceptable downtime for maintenance?"
- "Do we need real-time inventory updates?"

# Treating it like a single-tenant system
class SimpleProductService:
    def get_products(self, filters):
        # Missing tenant isolation!
        return self.db.query("SELECT * FROM products WHERE status = 'active'")

# Always include tenant context
class MultiTenantProductService:
    def get_products(self, store_id, filters):
        # Explicit tenant filtering
        return self.db.query("""
            SELECT * FROM products 
            WHERE store_id = $1 AND status = 'active'
        """, store_id)
    
    def explain_isolation_strategy(self):
        return {
            'database': 'Row-level security with store_id',
            'caching': 'Tenant-specific cache keys',
            'api': 'Tenant resolution from domain/token',
            'monitoring': 'Per-tenant metrics and alerts'
        }

# Shared resources without limits
class SharedResourcePool:
    def allocate_resources(self, store_id):
        # No quotas or limits!
        return self.resource_pool.allocate()

# Tenant-aware resource management
class TenantResourceManager:
    def allocate_resources(self, store_id, plan_type):
        # Get plan limits
        limits = self.get_plan_limits(plan_type)
        
        # Check current usage
        current_usage = self.get_tenant_usage(store_id)
        
        if current_usage.exceeds_limits(limits):
            raise ResourceQuotaExceededError()
        
        # Allocate with quotas
        allocation = {
            'cpu_quota': limits.cpu_cores,
            'memory_quota': limits.memory_gb,
            'storage_quota': limits.storage_gb,
            'api_rate_limit': limits.requests_per_second
        }
        
        return allocation

class ShardingStrategy:
    def explain_sharding_approach(self):
        return """
        Sharding Strategy:
        
        1. Small/Medium Stores (< 100K products):
           - Shared shards using consistent hashing
           - Multiple stores per shard
           - Cost-efficient resource utilization
        
        2. Large Stores (100K - 1M products):
           - Dedicated shard per store
           - Isolated performance
           - Predictable scaling
        
        3. Enterprise Stores (> 1M products):
           - Multiple dedicated shards
           - Horizontal partitioning by product category
           - Custom infrastructure
        
        Shard Selection:
        - Hash(store_id) % shard_count for small stores
        - Dedicated shard mapping for large stores
        - Dynamic rebalancing based on growth
        """

┌─────────────────────────────────────────────────────────┐
│                    Global CDN Layer                     │
└─────────────────────────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────┐
│              Multi-Tenant API Gateway                   │
│  (Tenant Resolution, Auth, Rate Limiting)               │
└─────────────────────────────────────────────────────────┘
                            ↓
        ┌──────────────────┴──────────────────┐
        ↓                                     ↓
┌──────────────────┐              ┌──────────────────┐
│ Storefront APIs  │              │   Admin APIs     │
│ - Products       │              │ - Store Mgmt     │
│ - Cart           │              │ - Orders         │
│ - Checkout       │              │ - Analytics      │
└──────────────────┘              └──────────────────┘
        ↓                                     ↓
┌─────────────────────────────────────────────────────────┐
│              Shared Platform Services                   │
│  Payment | Inventory | Notification | Search            │
└─────────────────────────────────────────────────────────┘
                            ↓
┌─────────────────────────────────────────────────────────┐
│                  Data Layer                             │
│  Sharded DB | Cache | Search | Analytics Warehouse     │
└─────────────────────────────────────────────────────────┘

-- Core tenant table
CREATE TABLE stores (
    store_id UUID PRIMARY KEY,
    merchant_id UUID NOT NULL,
    domain VARCHAR(255) UNIQUE,
    plan_type VARCHAR(50),
    shard_id INTEGER,  -- For routing queries
    created_at TIMESTAMP
);

-- Tenant-isolated data with RLS
CREATE TABLE products (
    product_id UUID PRIMARY KEY,
    store_id UUID NOT NULL,  -- Tenant identifier
    title VARCHAR(255),
    price DECIMAL(15,2),
    inventory INTEGER,
    created_at TIMESTAMP
);

-- Enable Row Level Security
ALTER TABLE products ENABLE ROW LEVEL SECURITY;

CREATE POLICY tenant_isolation ON products
    USING (store_id = current_setting('app.current_store_id')::UUID);

-- Indexes for multi-tenant queries
CREATE INDEX idx_products_store_id ON products(store_id);
CREATE INDEX idx_products_store_status ON products(store_id, status);

class ScalingStrategy:
    def explain_scaling_approach(self):
        return {
            'horizontal_scaling': {
                'application': 'Auto-scaling based on CPU/memory',
                'database': 'Sharding by store_id',
                'cache': 'Redis cluster with consistent hashing',
                'search': 'Elasticsearch cluster scaling'
            },
            'vertical_scaling': {
                'when': 'For large enterprise tenants',
                'approach': 'Dedicated infrastructure',
                'migration': 'Zero-downtime tenant migration'
            },
            'geographic_scaling': {
                'cdn': 'Global edge locations',
                'data_residency': 'Regional data storage',
                'routing': 'Geo-based traffic routing'
            }
        }

class TenantIsolationStrategy:
    def explain_isolation_mechanisms(self):
        return {
            'data_isolation': {
                'approach': 'Row-Level Security + Sharding',
                'enforcement': 'Database-level policies',
                'verification': 'Automated cross-tenant access tests'
            },
            'compute_isolation': {
                'approach': 'Resource quotas per tenant',
                'enforcement': 'Kubernetes resource limits',
                'monitoring': 'Per-tenant CPU/memory metrics'
            },
            'rate_limiting': {
                'approach': 'Token bucket per tenant',
                'limits': 'Based on pricing tier',
                'burst_handling': 'Temporary burst allowance'
            },
            'circuit_breakers': {
                'approach': 'Per-tenant circuit breakers',
                'trigger': 'Error rate threshold',
                'recovery': 'Gradual traffic restoration'
            }
        }

class TenantMigrationService:
    async def migrate_tenant_zero_downtime(self, store_id, target_shard):
        """
        Zero-downtime tenant migration process:
        
        1. Preparation Phase
           - Analyze tenant data size
           - Estimate migration time
           - Schedule during low-traffic period
        
        2. Replication Phase
           - Start replicating data to target shard
           - Keep source and target in sync
           - Monitor replication lag
        
        3. Dual-Write Phase
           - Enable writes to both shards
           - Verify data consistency
           - Monitor for errors
        
        4. Cutover Phase
           - Switch reads to target shard
           - Verify application functionality
           - Monitor performance metrics
        
        5. Cleanup Phase
           - Disable writes to source shard
           - Verify no traffic to source
           - Archive/delete source data
        """
        
        # Step 1: Replicate data
        await self.replicate_tenant_data(store_id, target_shard)
        
        # Step 2: Enable dual-write
        await self.enable_dual_write(store_id, target_shard)
        
        # Step 3: Verify consistency
        consistent = await self.verify_data_consistency(store_id, target_shard)
        if not consistent:
            await self.rollback_migration(store_id)
            raise MigrationError("Data consistency check failed")
        
        # Step 4: Switch reads
        await self.switch_reads_to_target(store_id, target_shard)
        
        # Step 5: Monitor and finalize
        await self.monitor_migration_health(store_id, duration_minutes=30)
        await self.finalize_migration(store_id, target_shard)

class PeakTrafficStrategy:
    def prepare_for_peak_event(self):
        return {
            'pre_event_preparation': {
                'timeline': '2 weeks before',
                'actions': [
                    'Pre-scale infrastructure to 5x capacity',
                    'Add database read replicas',
                    'Pre-warm caches with popular products',
                    'Increase CDN capacity',
                    'Set up enhanced monitoring'
                ]
            },
            'during_event': {
                'monitoring': 'Real-time dashboards',
                'auto_scaling': 'Aggressive scaling policies',
                'circuit_breakers': 'Protect critical services',
                'graceful_degradation': 'Disable non-essential features'
            },
            'post_event': {
                'scale_down': 'Gradual reduction over 24 hours',
                'analysis': 'Performance review',
                'optimization': 'Identify bottlenecks'
            }
        }

class MultiRegionStrategy:
    def explain_global_architecture(self):
        return """
        Multi-Region Architecture:
        
        1. Data Residency
           - Store data in customer's region
           - Comply with local regulations (GDPR, etc.)
           - Minimize cross-region data transfer
        
        2. Traffic Routing
           - GeoDNS for region selection
           - Latency-based routing
           - Failover to backup regions
        
        3. Data Synchronization
           - Async replication for analytics
           - Event streaming across regions
           - Conflict resolution strategies
        
        4. Regional Isolation
           - Independent deployments per region
           - Regional circuit breakers
           - Blast radius containment
        """

class EventDrivenDesign:
    def explain_event_architecture(self):
        return {
            'event_bus': 'Kafka for reliable event streaming',
            'event_types': [
                'order.created', 'order.fulfilled',
                'product.updated', 'inventory.changed',
                'payment.processed'
            ],
            'consumers': {
                'analytics': 'Real-time metrics',
                'notifications': 'Customer emails',
                'webhooks': 'Third-party integrations',
                'search_indexing': 'Elasticsearch updates'
            },
            'benefits': [
                'Loose coupling between services',
                'Async processing for better performance',
                'Easy to add new consumers',
                'Built-in audit trail'
            ]
        }

class MonitoringStrategy:
    def setup_monitoring(self):
        return {
            'tenant_level_metrics': {
                'requests_per_second': 'Per-tenant RPS',
                'error_rate': 'Per-tenant errors',
                'latency_p95': '95th percentile latency',
                'resource_usage': 'CPU, memory, storage'
            },
            'platform_metrics': {
                'total_throughput': 'Aggregate RPS',
                'database_performance': 'Query latency, connections',
                'cache_hit_ratio': 'Redis performance',
                'queue_depth': 'Background job backlog'
            },
            'business_metrics': {
                'orders_per_minute': 'Order volume',
                'revenue_per_minute': 'GMV tracking',
                'conversion_rate': 'Checkout success rate',
                'cart_abandonment': 'Lost sales tracking'
            },
            'alerting': {
                'critical': 'Page on-call for P0 issues',
                'warning': 'Slack notifications',
                'info': 'Dashboard updates'
            }
        }

class TestingStrategy:
    def explain_testing_approach(self):
        return {
            'unit_tests': 'Service-level logic',
            'integration_tests': 'Cross-service interactions',
            'tenant_isolation_tests': 'Verify no cross-tenant access',
            'load_tests': 'Simulate peak traffic',
            'chaos_engineering': 'Failure injection',
            'security_tests': 'Penetration testing',
            'compliance_tests': 'GDPR, PCI-DSS validation'
        }