omgkit 2.1.0 → 2.2.0

package/plugin/skills/omega/omega-architecture/SKILL.md

@@ -1,59 +1,858 @@
 ---
 name: omega-architecture
-description: Omega system architecture. Use for designing scalable systems.
+description: System architecture design with 7 Omega principles for scalable, resilient, and future-proof systems
+category: omega
+triggers:
+  - omega architecture
+  - system design
+  - scalable architecture
+  - distributed systems
+  - microservices design
+  - platform architecture
+  - infrastructure design
 ---
 
-# Omega Architecture Skill
+# Omega Architecture
 
-## 7 Omega Principles Applied
+Design **scalable, resilient, and future-proof systems** following the 7 Omega Principles. This skill provides architectural patterns, decision frameworks, and production-ready blueprints for building systems that scale to millions of users.
 
-### Ω1. Leverage Multiplication
-- Build systems, not features
-- Automate everything
-- Create multipliers
+## Purpose
 
-### Ω2. Transcendent Abstraction
-- Solve the class, not instance
-- Find patterns behind patterns
-- Build frameworks
+Build systems that transcend conventional architecture:
 
-### Ω3. Agentic Decomposition
-- Specialist components
-- Clear interfaces
-- Autonomous operation
+- Apply Omega principles to architectural decisions
+- Design for 1000x scale from day one
+- Create self-healing, autonomous systems
+- Build platforms, not just applications
+- Eliminate single points of failure
+- Achieve zero-marginal-cost scaling
+- Future-proof through abstraction layers
 
-### Ω5. Zero-Marginal-Cost Scaling
-- No per-unit cost
-- Horizontal scaling
-- Platform thinking
+## Features
 
-## Architecture Patterns
+### 1. The 7 Omega Principles in Architecture
 
-### Event-Driven
+```markdown
+## Omega Architectural Principles
+
+┌─────────────────────────────────────────────────────────────────────────┐
+│                    7 OMEGA ARCHITECTURE PRINCIPLES                       │
+├─────────────────────────────────────────────────────────────────────────┤
+│                                                                         │
+│  Ω1. LEVERAGE MULTIPLICATION                                            │
+│      → Build systems that amplify effort, not add to it                 │
+│      → Every component should be a force multiplier                     │
+│                                                                         │
+│  Ω2. TRANSCENDENT ABSTRACTION                                           │
+│      → Solve classes of problems, not individual instances              │
+│      → Build frameworks that spawn solutions                            │
+│                                                                         │
+│  Ω3. AGENTIC DECOMPOSITION                                              │
+│      → Autonomous components with clear boundaries                      │
+│      → Self-managing, self-healing subsystems                           │
+│                                                                         │
+│  Ω4. RECURSIVE IMPROVEMENT                                              │
+│      → Systems that optimize themselves over time                       │
+│      → Feedback loops that compound improvements                        │
+│                                                                         │
+│  Ω5. ZERO-MARGINAL-COST SCALING                                         │
+│      → No additional cost per user/request at scale                     │
+│      → Platform economics, not service economics                        │
+│                                                                         │
+│  Ω6. ANTIFRAGILE DESIGN                                                 │
+│      → Systems that grow stronger under stress                          │
+│      → Chaos becomes catalyst for improvement                           │
+│                                                                         │
+│  Ω7. COMPOSABLE PRIMITIVES                                              │
+│      → Lego-block components that combine infinitely                    │
+│      → New capabilities emerge from composition                         │
+│                                                                         │
+└─────────────────────────────────────────────────────────────────────────┘
 ```
-[Producer] → [Event Bus] → [Consumer]
-                       → [Consumer]
-                       → [Consumer]
+
+### 2. Ω1 Leverage Multiplication Architecture
+
+```typescript
+/**
+ * Leverage Multiplication: Build systems, not features
+ * Every architectural decision should multiply capability
+ */
+
+// ❌ Linear Architecture (effort grows with features)
+class LinearApproach {
+  createUser() { /* specific implementation */ }
+  createProduct() { /* specific implementation */ }
+  createOrder() { /* specific implementation */ }
+  // Each new entity = new implementation = linear growth
+}
+
+// ✅ Leverage Architecture (effort stays constant)
+interface Entity {
+  id: string;
+  type: string;
+  data: Record<string, unknown>;
+  metadata: EntityMetadata;
+}
+
+interface EntityMetadata {
+  createdAt: Date;
+  updatedAt: Date;
+  version: number;
+  audit: AuditTrail[];
+}
+
+class LeveragedEntitySystem {
+  private validators: Map<string, Validator>;
+  private hooks: Map<string, Hook[]>;
+  private storage: UnifiedStorage;
+
+  async create<T extends Entity>(type: string, data: T): Promise<T> {
+    // One implementation handles ALL entity types
+    const validated = await this.validators.get(type)?.validate(data);
+    await this.runHooks(type, 'beforeCreate', validated);
+    const result = await this.storage.create(type, validated);
+    await this.runHooks(type, 'afterCreate', result);
+    return result as T;
+  }
+
+  // Adding new entity type = configuration, not code
+  registerEntityType(type: string, config: EntityConfig): void {
+    this.validators.set(type, createValidator(config.schema));
+    this.hooks.set(type, config.hooks);
+  }
+}
+
+// Now ANY new entity is just configuration:
+entitySystem.registerEntityType('user', {
+  schema: userSchema,
+  hooks: [auditHook, notificationHook]
+});
+
+entitySystem.registerEntityType('product', {
+  schema: productSchema,
+  hooks: [inventoryHook, searchIndexHook]
+});
+```
+
+### 3. Ω3 Agentic Decomposition Pattern
+
+```typescript
+/**
+ * Agentic Decomposition: Autonomous, self-managing services
+ * Each service operates independently with clear contracts
+ */
+
+// Service Contract Definition
+interface ServiceContract {
+  name: string;
+  version: string;
+  capabilities: string[];
+  dependencies: ServiceDependency[];
+  healthCheck: () => Promise<HealthStatus>;
+  metrics: () => MetricsSnapshot;
+}
+
+// Self-Healing Service Base
+abstract class AgenticService implements ServiceContract {
+  abstract name: string;
+  abstract version: string;
+  abstract capabilities: string[];
+  dependencies: ServiceDependency[] = [];
+
+  private circuitBreaker: CircuitBreaker;
+  private healthMonitor: HealthMonitor;
+  private autoScaler: AutoScaler;
+
+  constructor() {
+    // Self-monitoring
+    this.healthMonitor = new HealthMonitor({
+      checkInterval: 5000,
+      onUnhealthy: () => this.selfHeal()
+    });
+
+    // Self-protecting
+    this.circuitBreaker = new CircuitBreaker({
+      failureThreshold: 5,
+      resetTimeout: 30000,
+      onOpen: () => this.notifyDegradation()
+    });
+
+    // Self-scaling
+    this.autoScaler = new AutoScaler({
+      minInstances: 2,
+      maxInstances: 100,
+      targetCPU: 70,
+      targetMemory: 80
+    });
+  }
+
+  protected async executeWithResilience<T>(
+    operation: () => Promise<T>,
+    fallback?: () => T
+  ): Promise<T> {
+    return this.circuitBreaker.execute(operation, fallback);
+  }
+
+  private async selfHeal(): Promise<void> {
+    console.log(`[${this.name}] Self-healing initiated`);
+    await this.clearCaches();
+    await this.reconnectDependencies();
+    await this.reloadConfiguration();
+  }
+
+  async healthCheck(): Promise<HealthStatus> {
+    const dependencyHealth = await Promise.all(
+      this.dependencies.map(dep => dep.checkHealth())
+    );
+
+    return {
+      service: this.name,
+      status: dependencyHealth.every(h => h.healthy) ? 'healthy' : 'degraded',
+      dependencies: dependencyHealth,
+      metrics: this.metrics()
+    };
+  }
+
+  abstract metrics(): MetricsSnapshot;
+  protected abstract clearCaches(): Promise<void>;
+  protected abstract reconnectDependencies(): Promise<void>;
+  protected abstract reloadConfiguration(): Promise<void>;
+}
+
+// Example: Autonomous Order Service
+class OrderService extends AgenticService {
+  name = 'order-service';
+  version = '2.1.0';
+  capabilities = ['create-order', 'process-payment', 'track-fulfillment'];
+
+  async createOrder(request: CreateOrderRequest): Promise<Order> {
+    return this.executeWithResilience(
+      async () => {
+        const validated = await this.validateOrder(request);
+        const order = await this.persistOrder(validated);
+        await this.emitEvent('order.created', order);
+        return order;
+      },
+      () => this.queueForRetry(request) // Fallback: queue for later
+    );
+  }
+}
+```
+
+### 4. Ω5 Zero-Marginal-Cost Architecture
+
+```typescript
+/**
+ * Zero-Marginal-Cost Scaling: Platform architecture
+ * Cost per user/request approaches zero at scale
+ */
+
+// Platform Architecture Blueprint
+interface PlatformArchitecture {
+  // Compute: Serverless (pay per execution, not capacity)
+  compute: ServerlessConfig;
+
+  // Storage: Object storage with CDN (infinite scale, usage-based)
+  storage: EdgeStorageConfig;
+
+  // Data: Distributed with automatic sharding
+  database: DistributedDBConfig;
+
+  // Caching: Edge caching eliminates repeated computation
+  cache: EdgeCacheConfig;
+}
+
+const platformConfig: PlatformArchitecture = {
+  compute: {
+    provider: 'cloudflare-workers',
+    // Runs at the edge - 0ms cold start
+    // Pay per request, not per hour
+    pricing: 'per-invocation',
+    limits: {
+      cpuTime: '50ms',
+      memory: '128MB'
+    }
+  },
+
+  storage: {
+    provider: 'r2', // S3-compatible, zero egress fees
+    cdn: {
+      enabled: true,
+      ttl: '1y', // Immutable assets cached forever
+      purgeOnDeploy: true
+    }
+  },
+
+  database: {
+    provider: 'planetscale', // MySQL-compatible, auto-sharding
+    // Or: cockroachdb, vitess, yugabyte
+    sharding: 'automatic',
+    replicas: {
+      read: 'multi-region',
+      write: 'primary-with-failover'
+    }
+  },
+
+  cache: {
+    layers: [
+      { type: 'browser', ttl: '1h' },
+      { type: 'cdn-edge', ttl: '24h' },
+      { type: 'regional', ttl: '1h' },
+      { type: 'origin', ttl: '5m' }
+    ]
+  }
+};
+
+// Implementation: Compute moves to data, not vice versa
+class ZeroMarginalCostAPI {
+  // Edge function - runs in 300+ locations worldwide
+  async handleRequest(request: Request): Promise<Response> {
+    const cacheKey = this.generateCacheKey(request);
+
+    // Layer 1: Edge cache (0 compute cost)
+    const cached = await this.edgeCache.get(cacheKey);
+    if (cached) return cached;
+
+    // Layer 2: Regional compute (minimal latency)
+    const result = await this.processAtEdge(request);
+
+    // Cache for future requests (amortize cost)
+    await this.edgeCache.set(cacheKey, result, { ttl: 3600 });
+
+    return result;
+  }
+
+  private async processAtEdge(request: Request): Promise<Response> {
+    // Use read replicas closest to user
+    const db = this.getRegionalReplica(request.cf?.colo);
+
+    // Streaming response - start sending immediately
+    const stream = new TransformStream();
+    const writer = stream.writable.getWriter();
+
+    // Process in chunks - constant memory usage
+    this.streamResults(db, writer);
+
+    return new Response(stream.readable);
+  }
+}
+```
+
+### 5. Event-Driven Architecture Pattern
+
+```typescript
+/**
+ * Event-Driven: Loose coupling, infinite scalability
+ * Services communicate through events, not direct calls
+ */
+
+// Event Schema with Versioning
+interface DomainEvent<T = unknown> {
+  id: string;
+  type: string;
+  version: number;
+  timestamp: Date;
+  source: string;
+  correlationId: string;
+  causationId?: string;
+  data: T;
+  metadata: EventMetadata;
+}
+
+// Event Bus Implementation
+class EventBus {
+  private handlers: Map<string, EventHandler[]> = new Map();
+  private deadLetterQueue: DeadLetterQueue;
+  private eventStore: EventStore;
+
+  async publish<T>(event: DomainEvent<T>): Promise<void> {
+    // 1. Persist event (event sourcing)
+    await this.eventStore.append(event);
+
+    // 2. Dispatch to handlers
+    const handlers = this.handlers.get(event.type) || [];
+
+    await Promise.allSettled(
+      handlers.map(handler =>
+        this.executeHandler(handler, event)
+      )
+    );
+  }
+
+  private async executeHandler(
+    handler: EventHandler,
+    event: DomainEvent
+  ): Promise<void> {
+    const maxRetries = 3;
+    let attempt = 0;
+
+    while (attempt < maxRetries) {
+      try {
+        await handler.handle(event);
+        return;
+      } catch (error) {
+        attempt++;
+        if (attempt >= maxRetries) {
+          await this.deadLetterQueue.add(event, error);
+        }
+        await this.delay(Math.pow(2, attempt) * 1000);
+      }
+    }
+  }
+
+  subscribe(eventType: string, handler: EventHandler): Unsubscribe {
+    const handlers = this.handlers.get(eventType) || [];
+    handlers.push(handler);
+    this.handlers.set(eventType, handlers);
+
+    return () => {
+      const index = handlers.indexOf(handler);
+      if (index > -1) handlers.splice(index, 1);
+    };
+  }
+}
+
+// Saga Pattern for Distributed Transactions
+class OrderSaga {
+  private eventBus: EventBus;
+
+  constructor(eventBus: EventBus) {
+    this.eventBus = eventBus;
+
+    // React to events
+    eventBus.subscribe('order.created', this.handleOrderCreated);
+    eventBus.subscribe('payment.completed', this.handlePaymentCompleted);
+    eventBus.subscribe('payment.failed', this.handlePaymentFailed);
+    eventBus.subscribe('inventory.reserved', this.handleInventoryReserved);
+  }
+
+  handleOrderCreated = async (event: DomainEvent<Order>): Promise<void> => {
+    // Start saga - reserve inventory
+    await this.eventBus.publish({
+      type: 'inventory.reserve',
+      data: {
+        orderId: event.data.id,
+        items: event.data.items
+      },
+      correlationId: event.correlationId,
+      causationId: event.id
+    });
+  };
+
+  handlePaymentFailed = async (event: DomainEvent): Promise<void> => {
+    // Compensating action - release inventory
+    await this.eventBus.publish({
+      type: 'inventory.release',
+      data: { orderId: event.data.orderId },
+      correlationId: event.correlationId,
+      causationId: event.id
+    });
+
+    // Update order status
+    await this.eventBus.publish({
+      type: 'order.cancelled',
+      data: {
+        orderId: event.data.orderId,
+        reason: 'payment_failed'
+      },
+      correlationId: event.correlationId,
+      causationId: event.id
+    });
+  };
+}
 ```
 
-### Microservices
+### 6. Antifragile System Design
+
+```typescript
+/**
+ * Ω6 Antifragile: Systems that grow stronger under stress
+ * Embrace failure as a catalyst for improvement
+ */
+
+// Chaos Engineering Integration
+class AntifragileSystem {
+  private chaosEngine: ChaosEngine;
+  private adaptiveConfig: AdaptiveConfiguration;
+  private learningSystem: LearningSystem;
+
+  constructor() {
+    this.chaosEngine = new ChaosEngine({
+      // Inject controlled failures
+      experiments: [
+        { type: 'latency', probability: 0.01, maxDelay: 500 },
+        { type: 'failure', probability: 0.001, services: ['non-critical'] },
+        { type: 'resource-pressure', probability: 0.01 }
+      ],
+      // Automatically disable during incidents
+      safetyLimits: {
+        errorRate: 0.05,
+        p99Latency: 1000
+      }
+    });
+
+    this.learningSystem = new LearningSystem();
+  }
+
+  // Adaptive Circuit Breaker - learns optimal thresholds
+  private createAdaptiveBreaker(serviceName: string): CircuitBreaker {
+    return new AdaptiveCircuitBreaker({
+      serviceName,
+      // Initial conservative settings
+      initialThreshold: 5,
+      initialTimeout: 30000,
+      // Learn from traffic patterns
+      adaptationRate: 0.1,
+      onStateChange: (from, to, metrics) => {
+        this.learningSystem.recordTransition(serviceName, from, to, metrics);
+      }
+    });
+  }
+
+  // Automatic fallback escalation
+  async executeWithEscalation<T>(
+    primary: () => Promise<T>,
+    fallbacks: Array<() => Promise<T>>,
+    options: ExecutionOptions
+  ): Promise<T> {
+    // Try primary
+    try {
+      return await this.withTimeout(primary(), options.timeout);
+    } catch (primaryError) {
+      // Learn from failure
+      this.learningSystem.recordFailure('primary', primaryError);
+    }
+
+    // Escalate through fallbacks
+    for (let i = 0; i < fallbacks.length; i++) {
+      try {
+        const result = await this.withTimeout(
+          fallbacks[i](),
+          options.timeout * (i + 2) // Progressively longer timeouts
+        );
+        // Record successful fallback
+        this.learningSystem.recordFallbackSuccess(i);
+        return result;
+      } catch (error) {
+        this.learningSystem.recordFailure(`fallback-${i}`, error);
+      }
+    }
+
+    throw new AllFallbacksExhaustedError();
+  }
+
+  // Self-improving configuration
+  async adaptConfiguration(): Promise<void> {
+    const insights = await this.learningSystem.getInsights();
+
+    for (const insight of insights) {
+      switch (insight.type) {
+        case 'timeout-too-short':
+          await this.adaptiveConfig.increase(insight.key, 1.5);
+          break;
+        case 'retry-ineffective':
+          await this.adaptiveConfig.decrease(`${insight.service}.retries`, 0.5);
+          break;
+        case 'cache-miss-pattern':
+          await this.adaptiveConfig.set(
+            `${insight.key}.preload`,
+            insight.suggestedKeys
+          );
+          break;
+      }
+    }
+  }
+}
+
+// Bulkhead Pattern - Isolate failures
+class BulkheadExecutor {
+  private pools: Map<string, ResourcePool>;
+
+  constructor(config: BulkheadConfig) {
+    // Separate pools for different concerns
+    this.pools = new Map([
+      ['critical', new ResourcePool({ size: 20, queue: 100 })],
+      ['standard', new ResourcePool({ size: 10, queue: 50 })],
+      ['background', new ResourcePool({ size: 5, queue: 1000 })]
+    ]);
+  }
+
+  async execute<T>(
+    priority: 'critical' | 'standard' | 'background',
+    task: () => Promise<T>
+  ): Promise<T> {
+    const pool = this.pools.get(priority)!;
+
+    // Critical operations never affected by standard/background load
+    return pool.acquire(async (resource) => {
+      return task();
+    });
+  }
+}
 ```
-[API Gateway]
-     │
-┌────┼────┐
-▼    ▼    ▼
-[A] [B]  [C]
+
+### 7. Architecture Decision Framework
+
+```markdown
+## Omega Architecture Decision Template
+
+### Context
+What problem are we solving?
+What constraints exist?
+
+### Omega Principles Check
+For EVERY architecture decision, verify:
+
+| Principle | Question | Assessment |
+|-----------|----------|------------|
+| Ω1 Leverage | Does this multiply our capability? | |
+| Ω2 Abstraction | Are we solving a class of problems? | |
+| Ω3 Agentic | Can this operate autonomously? | |
+| Ω4 Recursive | Will this improve itself over time? | |
+| Ω5 Zero-Marginal | Does cost scale sub-linearly? | |
+| Ω6 Antifragile | Does it grow stronger under stress? | |
+| Ω7 Composable | Can it combine with other components? | |
+
+### Scale Questions
+1. What happens at 10x current load?
+2. What happens at 100x?
+3. What happens at 1000x?
+4. What's the cost curve at each level?
+
+### Failure Analysis
+1. What's the blast radius of failure?
+2. How do we detect it?
+3. How do we recover?
+4. How do we prevent recurrence?
+
+### Decision
+[The chosen approach]
+
+### Consequences
+- Benefits:
+- Risks:
+- Technical debt incurred:
 ```
 
-### Serverless
+## Use Cases
+
+### E-commerce Platform Architecture
+
+```typescript
+/**
+ * Complete e-commerce platform following Omega principles
+ */
+
+// Domain Events
+type EcommerceEvent =
+  | { type: 'product.created'; data: Product }
+  | { type: 'cart.updated'; data: Cart }
+  | { type: 'order.placed'; data: Order }
+  | { type: 'payment.processed'; data: Payment }
+  | { type: 'inventory.updated'; data: InventoryChange }
+  | { type: 'shipment.dispatched'; data: Shipment };
+
+// Service Boundaries (Agentic Decomposition)
+const serviceArchitecture = {
+  // Each service is autonomous with clear boundaries
+  catalog: {
+    responsibilities: ['product-management', 'search', 'recommendations'],
+    data: ['products', 'categories', 'reviews'],
+    events: ['product.*'],
+    scaling: 'read-heavy, edge-cached'
+  },
+
+  cart: {
+    responsibilities: ['cart-management', 'pricing', 'promotions'],
+    data: ['carts', 'promotions'],
+    events: ['cart.*'],
+    scaling: 'session-based, regional'
+  },
+
+  order: {
+    responsibilities: ['order-processing', 'fulfillment-coordination'],
+    data: ['orders', 'order-items'],
+    events: ['order.*'],
+    scaling: 'write-heavy, strongly-consistent'
+  },
+
+  payment: {
+    responsibilities: ['payment-processing', 'refunds', 'fraud-detection'],
+    data: ['transactions', 'payment-methods'],
+    events: ['payment.*'],
+    scaling: 'PCI-compliant, isolated'
+  },
+
+  inventory: {
+    responsibilities: ['stock-management', 'reservations', 'alerts'],
+    data: ['inventory', 'warehouses'],
+    events: ['inventory.*'],
+    scaling: 'real-time, multi-region sync'
+  },
+
+  shipping: {
+    responsibilities: ['carrier-integration', 'tracking', 'returns'],
+    data: ['shipments', 'carriers'],
+    events: ['shipment.*'],
+    scaling: 'async, event-driven'
+  }
+};
+
+// Infrastructure Blueprint
+const infrastructureConfig = `
+# Kubernetes Architecture
+
+┌─────────────────────────────────────────────────────────────────┐
+│                         EDGE LAYER                               │
+│  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐            │
+│  │ CDN     │  │ CDN     │  │ CDN     │  │ CDN     │            │
+│  │ US-EAST │  │ EU-WEST │  │ AP-SOUTH│  │ AP-NORTH│            │
+│  └────┬────┘  └────┬────┘  └────┬────┘  └────┬────┘            │
+└───────┼────────────┼────────────┼────────────┼──────────────────┘
+        │            │            │            │
+┌───────┴────────────┴────────────┴────────────┴──────────────────┐
+│                    API GATEWAY (Global)                          │
+│  ┌──────────────────────────────────────────────────────────┐   │
+│  │ Rate Limiting │ Auth │ Routing │ Load Balancing          │   │
+│  └──────────────────────────────────────────────────────────┘   │
+└─────────────────────────────┬───────────────────────────────────┘
+                              │
+┌─────────────────────────────┴───────────────────────────────────┐
+│                    SERVICE MESH (Istio)                          │
+│                                                                  │
+│  ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐   │
+│  │ Catalog │ │  Cart   │ │  Order  │ │ Payment │ │Inventory│   │
+│  │ Service │ │ Service │ │ Service │ │ Service │ │ Service │   │
+│  └────┬────┘ └────┬────┘ └────┬────┘ └────┬────┘ └────┬────┘   │
+│       │          │          │          │          │            │
+└───────┼──────────┼──────────┼──────────┼──────────┼────────────┘
+        │          │          │          │          │
+┌───────┴──────────┴──────────┴──────────┴──────────┴────────────┐
+│                      EVENT BUS (Kafka)                          │
+│  ┌──────────────────────────────────────────────────────────┐   │
+│  │ Topics: products│carts│orders│payments│inventory│shipments│  │
+│  └──────────────────────────────────────────────────────────┘   │
+└─────────────────────────────────────────────────────────────────┘
+`;
 ```
-[Request] → [Function] → [Database]
-                      → [Queue]
-                      → [Storage]
+
+### SaaS Multi-Tenant Architecture
+
+```typescript
+/**
+ * Multi-tenant SaaS following Zero-Marginal-Cost principles
+ */
+
+// Tenant Isolation Strategies
+type IsolationStrategy =
+  | 'shared-database' // Cost-efficient, row-level isolation
+  | 'schema-per-tenant' // Balance of isolation and cost
+  | 'database-per-tenant'; // Maximum isolation, higher cost
+
+interface TenantConfig {
+  id: string;
+  tier: 'free' | 'pro' | 'enterprise';
+  isolation: IsolationStrategy;
+  customDomain?: string;
+  dataRegion: string;
+}
+
+class MultiTenantArchitecture {
+  // Tenant-aware query builder
+  createQueryContext(tenantId: string): QueryContext {
+    return {
+      // Automatic tenant filtering on all queries
+      defaultFilters: { tenant_id: tenantId },
+      // Connection pooling by tenant tier
+      pool: this.getPoolForTenant(tenantId),
+      // Read replica routing
+      readPreference: this.getReadPreference(tenantId)
+    };
+  }
+
+  // Dynamic resource allocation by tier
+  private getResourceLimits(tier: string): ResourceLimits {
+    const limits: Record<string, ResourceLimits> = {
+      free: {
+        requestsPerMinute: 60,
+        storageGB: 1,
+        computeUnits: 10,
+        features: ['core']
+      },
+      pro: {
+        requestsPerMinute: 600,
+        storageGB: 50,
+        computeUnits: 100,
+        features: ['core', 'advanced', 'integrations']
+      },
+      enterprise: {
+        requestsPerMinute: 6000,
+        storageGB: 500,
+        computeUnits: 1000,
+        features: ['core', 'advanced', 'integrations', 'sso', 'audit']
+      }
+    };
+    return limits[tier];
+  }
+}
+
+// Feature Flag System (Composable)
+class FeatureFlagSystem {
+  async isEnabled(
+    flag: string,
+    context: { tenant: string; user?: string }
+  ): Promise<boolean> {
+    // Layered evaluation
+    const checks = [
+      this.checkGlobalOverride(flag),
+      this.checkTenantOverride(flag, context.tenant),
+      this.checkUserOverride(flag, context.user),
+      this.checkPercentageRollout(flag, context),
+      this.checkDefaultValue(flag)
+    ];
+
+    for (const check of checks) {
+      const result = await check;
+      if (result !== undefined) return result;
+    }
+
+    return false;
+  }
+}
 ```
 
-## Design Questions
-1. How does this scale to 1000x?
-2. What's the single point of failure?
-3. How do we deploy without downtime?
-4. What's the cost at scale?
+## Best Practices
+
+### Do's
+
+- **Apply all 7 Omega principles** to every architectural decision
+- **Design for 1000x scale** from the beginning
+- **Use event-driven patterns** for loose coupling
+- **Implement circuit breakers** at all service boundaries
+- **Build self-healing capabilities** into every service
+- **Measure and optimize** cost per transaction
+- **Document decisions** using the ADR template
+- **Test failure scenarios** with chaos engineering
+- **Use infrastructure as code** for reproducibility
+- **Implement observability** (logs, metrics, traces) everywhere
+
+### Don'ts
+
+- Don't build monoliths that can't be decomposed
+- Don't create tight coupling between services
+- Don't ignore failure modes in design
+- Don't scale vertically when horizontal is possible
+- Don't hardcode configuration
+- Don't skip capacity planning
+- Don't deploy without health checks
+- Don't rely on synchronous calls for non-critical paths
+- Don't ignore data consistency requirements
+- Don't underestimate the cost of distributed systems
+
+## References
+
+- [Designing Data-Intensive Applications](https://dataintensive.net/)
+- [Building Microservices](https://www.oreilly.com/library/view/building-microservices-2nd/9781492034018/)
+- [Release It!](https://pragprog.com/titles/mnee2/release-it-second-edition/)
+- [Site Reliability Engineering](https://sre.google/sre-book/table-of-contents/)
+- [Cloud Design Patterns](https://docs.microsoft.com/en-us/azure/architecture/patterns/)