Architect: "Let's invent a new way to support the roof!"
Result: Roof collapses ❌
Cost: $100,000 to rebuild
Time wasted: 6 months

Architect: "Let's use load-bearing walls (a proven pattern)"
Result: Roof stays up ✅
Cost: $0 (used proven method)
Time saved: 6 months

Your Entire Application (1 server):
├── Web UI (React)
├── API (Node.js)
├── Database (SQLite file)
└── Files (local disk)

Cost: $50/month (one VM)
Downtime: If server crashes, everything is down ❌
Scaling: Can't handle more than 100 users

Tier 1: Web Servers (2 VMs)
├── Load Balancer (distributes traffic)
├── VM 1: React app
└── VM 2: React app

Tier 2: API Servers (2 VMs)
├── VM 3: Node.js API
└── VM 4: Node.js API

Tier 3: Database (1 server)
└── Azure SQL (managed database)

Cost: $500/month
Uptime: 99.9% (one VM can fail, others keep running)
Scaling: Can handle 10,000 concurrent users

User Request
  ↓
API Gateway (Azure API Management)
  ↓
├── Auth Service (handles login)
├── Order Service (handles orders)
├── Payment Service (handles payments)
├── Inventory Service (checks stock)
└── Notification Service (sends emails)

Each service has its own:
- Database (data isolation)
- Code repository (deploy independently)
- Team (organizational independence)

Cost: $5,000/month
Uptime: 99.99% (services fail independently)
Scaling: Can handle 1,000,000 users

Global Load Balancer (Azure Front Door)
  ↓
├── US Region (East US)
│   ├── Microservices
│   ├── Database (primary)
│   └── Cache (Redis)
│
├── Europe Region (West Europe)
│   ├── Microservices
│   ├── Database (replica)
│   └── Cache (Redis)
│
└── Asia Region (Southeast Asia)
    ├── Microservices
    ├── Database (replica)
    └── Cache (Redis)

User in US → Routes to US region (low latency)
User in EU → Routes to EU region (low latency)

Cost: $50,000/month
Uptime: 99.999% (entire region can fail, others continue)
Latency: <50ms anywhere in world
Scaling: Can handle 100,000,000 users

Startup Founder: "We're going to be the next Netflix!"
Architect: "Let's build a microservices architecture from day 1!"

Result:
- 6 months building infrastructure
- $100,000 spent
- 0 customers ❌
- Company runs out of money

2007: Started with a MONOLITH (single Ruby on Rails app)
- Simple architecture
- Fast to build
- Delivered value to customers quickly ✅

2009: Had 10 million subscribers → THEN migrated to microservices
- Had revenue to fund the migration
- Had real problems to solve (scaling bottlenecks)
- Had data to inform architecture decisions

Q1: How many users do you have?

├─ 0-100 users
│  └─ Answer: Single Server ($50/month) ✅
│     Azure Service: App Service Basic tier or single B2s VM
│
├─ 100-10,000 users
│  └─ Answer: N-Tier Architecture ($500/month) ✅
│     Azure Services: App Service Standard + Azure SQL + Redis
│
├─ 10,000-1,000,000 users
│  └─ Answer: Microservices ($5,000/month) ✅
│     Azure Services: AKS + Cosmos DB + Service Bus + Front Door
│
└─ 1,000,000+ users
   └─ Answer: Multi-Region ($50,000/month) ✅
   Azure Services: Multi-region AKS + Cosmos DB multi-master + Front Door

Reminder: You can ALWAYS migrate later!
- Start simple → Evolve as you grow
- Don't build for 1M users when you have 100
- The cost of premature complexity is both financial (infrastructure)
  and organizational (slower iteration, harder debugging)

Hub VNet (10.0.0.0/16)
├── Azure Firewall
├── VPN Gateway
├── Azure Bastion
└── Shared Services (DNS, monitoring)

Spoke 1: Production (10.1.0.0/16)
├── Web Tier
├── App Tier
└── Data Tier

Spoke 2: Development (10.2.0.0/16)
├── Dev Environment
└── Testing

Spoke 3: Management (10.3.0.0/16)
├── Jump Boxes
└── Monitoring Tools

Traffic Flow:
- All internet traffic → Azure Firewall
- Spoke-to-spoke → Via hub (UDRs)
- On-premises → VPN Gateway

Region 1: East US
- App Service (active)
- Cosmos DB (write enabled)
- Azure SQL (read replica)

Region 2: West Europe
- App Service (active)
- Cosmos DB (write enabled)
- Azure SQL (read replica)

Region 3: Southeast Asia
- App Service (active)
- Cosmos DB (write enabled)
- Azure SQL (read replica)

Front Door:
- Routes to nearest healthy region
- Latency-based routing
- Automatic failover

Data Consistency:
- Cosmos DB: Multi-master with conflict resolution
- Azure SQL: Active geo-replication

using Polly;
using Polly.CircuitBreaker;

// Configure Circuit Breaker
var circuitBreakerPolicy = Policy
    .Handle<HttpRequestException>()
    .CircuitBreakerAsync(
        exceptionsAllowedBeforeBreaking: 3,  // Open after 3 failures
        durationOfBreak: TimeSpan.FromSeconds(30)  // Stay open for 30s
    );

// Use it
try
{
    await circuitBreakerPolicy.ExecuteAsync(async () =>
    {
        var response = await httpClient.GetAsync("https://api.example.com/data");
        response.EnsureSuccessStatusCode();
        return await response.Content.ReadAsStringAsync();
    });
}
catch (BrokenCircuitException)
{
    // Circuit is open, fail fast
    _logger.LogWarning("Circuit breaker is open, returning cached data");
    return GetCachedData();
}

var retryPolicy = Policy
    .Handle<SqlException>(ex => ex.Number == -2) // Timeout error
    .Or<HttpRequestException>()
    .WaitAndRetryAsync(
        retryCount: 3,
        sleepDurationProvider: attempt => TimeSpan.FromSeconds(Math.Pow(2, attempt)),
        onRetry: (exception, timeSpan, retryCount, context) =>
        {
            _logger.LogWarning(
                $"Retry {retryCount} after {timeSpan.Seconds}s due to {exception.Message}"
            );
        }
    );

// Execute with retries
var result = await retryPolicy.ExecuteAsync(async () =>
{
    return await _dbContext.Orders.ToListAsync();
});

var jitter = TimeSpan.FromMilliseconds(Random.Shared.Next(0, 1000));
sleepDurationProvider: attempt => TimeSpan.FromSeconds(Math.Pow(2, attempt)) + jitter

var timeoutPolicy = Policy
    .TimeoutAsync(
        seconds: 3,
        onTimeoutAsync: (context, timeSpan, task) =>
        {
            _logger.LogError($"Request timed out after {timeSpan.Seconds}s");
            return Task.CompletedTask;
        }
    );

try
{
    await timeoutPolicy.ExecuteAsync(async ct =>
    {
        return await httpClient.GetAsync("https://slow-api.com/data", ct);
    }, CancellationToken.None);
}
catch (TimeoutRejectedException)
{
    return GetFallbackData();
}

<!-- APIM Policy -->
<policies>
  <inbound>
    <base />
    <timeout seconds="5" />
  </inbound>
</policies>

var bulkheadPolicy = Policy
    .BulkheadAsync(
        maxParallelization: 10,   // Max 10 concurrent executions
        maxQueuingActions: 20,    // Max 20 waiting in queue
        onBulkheadRejectedAsync: context =>
        {
            _logger.LogWarning("Bulkhead rejected request - too many concurrent calls");
            return Task.CompletedTask;
        }
    );

try
{
    await bulkheadPolicy.ExecuteAsync(async () =>
    {
        return await CallExternalApi();
    });
}
catch (BulkheadRejectedException)
{
    return StatusCode(503, "Service temporarily overloaded");
}

var fallbackPolicy = Policy<string>
    .Handle<HttpRequestException>()
    .FallbackAsync(
        fallbackValue: "{\"message\": \"Cached data from 10 minutes ago\"}",
        onFallbackAsync: (result, context) =>
        {
            _logger.LogWarning("Using fallback value due to API failure");
            return Task.CompletedTask;
        }
    );

var result = await fallbackPolicy.ExecuteAsync(async () =>
{
    var response = await httpClient.GetAsync("https://api.example.com/recommendations");
    return await response.Content.ReadAsStringAsync();
});

// Build a resilience pipeline
var resilienceStrategy = Policy.WrapAsync(
    // 1. Fallback (outermost)
    Policy<HttpResponseMessage>
        .Handle<Exception>()
        .FallbackAsync(new HttpResponseMessage
        {
            StatusCode = HttpStatusCode.OK,
            Content = new StringContent(GetCachedData())
        }),

    // 2. Circuit Breaker
    Policy
        .Handle<HttpRequestException>()
        .CircuitBreakerAsync(
            exceptionsAllowedBeforeBreaking: 3,
            durationOfBreak: TimeSpan.FromSeconds(30)
        ),

    // 3. Retry with exponential backoff
    Policy
        .Handle<HttpRequestException>()
        .WaitAndRetryAsync(
            retryCount: 3,
            sleepDurationProvider: attempt => TimeSpan.FromSeconds(Math.Pow(2, attempt))
        ),

    // 4. Timeout (innermost)
    Policy
        .TimeoutAsync(TimeSpan.FromSeconds(5))
);

// Execute request with full resilience
var response = await resilienceStrategy.ExecuteAsync(async () =>
{
    return await httpClient.GetAsync("https://api.example.com/data");
});

{
  "healthCheckPath": "/health",
  "loadBalancing": "LeastRequests",
  "autoHealEnabled": true,
  "autoHealRules": {
    "triggers": {
      "statusCodes": [{ "status": 500, "count": 10, "timeInterval": "00:01:00" }]
    },
    "actions": {
      "actionType": "Recycle",
      "minProcessExecutionTime": "00:01:00"
    }
  }
}

[FunctionName("ProcessOrder")]
public async Task ProcessOrder([OrchestrationTrigger] IDurableOrchestrationContext context)
{
    var retryOptions = new RetryOptions(
        firstRetryInterval: TimeSpan.FromSeconds(5),
        maxNumberOfAttempts: 3
    );

    await context.CallActivityWithRetryAsync("ChargePayment", retryOptions, order);
}

<policies>
  <inbound>
    <base />
    <retry condition="@(context.Response.StatusCode >= 500)"
           count="3"
           interval="2"
           delta="1"
           max-interval="10">
      <forward-request timeout="5" />
    </retry>
  </inbound>
  <backend>
    <limit-concurrency key="@(context.Request.IpAddress)" max-count="10" />
  </backend>
</policies>

{
  "type": "Microsoft.Chaos/experiments",
  "name": "simulate-api-failure",
  "properties": {
    "selectors": [
      {
        "type": "List",
        "targets": [
          {
            "type": "Microsoft.AppService/sites",
            "id": "/subscriptions/.../myapp"
          }
        ]
      }
    ],
    "steps": [
      {
        "name": "Inject 50% HTTP 500 errors",
        "branches": [
          {
            "name": "Fault Injection",
            "actions": [
              {
                "type": "continuous",
                "duration": "PT10M",
                "parameters": [
                  {
                    "key": "statusCode",
                    "value": "500"
                  },
                  {
                    "key": "percentage",
                    "value": "50"
                  }
                ],
                "name": "urn:csci:microsoft:appService:http/statusCode"
              }
            ]
          }
        ]
      }
    ]
  }
}

// Commands modify state
public class CreateOrderCommand
{
    public string UserId { get; set; }
    public List<OrderItem> Items { get; set; }
}

public class OrderCommandHandler
{
    private readonly ApplicationDbContext _db;
    private readonly IEventBus _eventBus;

    public async Task<int> Handle(CreateOrderCommand command)
    {
        // Write to normalized database
        var order = new Order
        {
            UserId = command.UserId,
            Items = command.Items,
            CreatedAt = DateTime.UtcNow,
            Status = OrderStatus.Pending
        };

        _db.Orders.Add(order);
        await _db.SaveChangesAsync();

        // Publish event for read model
        await _eventBus.PublishAsync(new OrderCreatedEvent
        {
            OrderId = order.Id,
            UserId = order.UserId,
            TotalAmount = order.Items.Sum(x => x.Price * x.Quantity),
            CreatedAt = order.CreatedAt
        });

        return order.Id;
    }
}

// Queries read from denormalized view
public class GetUserOrdersQuery
{
    public string UserId { get; set; }
}

public class OrderQueryHandler
{
    private readonly ICosmosDbClient _cosmosDb;  // Read database

    public async Task<List<OrderSummary>> Handle(GetUserOrdersQuery query)
    {
        // Read from denormalized Cosmos DB (fast, no joins)
        return await _cosmosDb.QueryAsync<OrderSummary>(
            $"SELECT * FROM c WHERE c.userId = '{query.UserId}' ORDER BY c.createdAt DESC"
        );
    }
}

// Denormalized read model
public class OrderSummary
{
    public int OrderId { get; set; }
    public string UserId { get; set; }
    public decimal TotalAmount { get; set; }
    public string Status { get; set; }
    public DateTime CreatedAt { get; set; }
    public int ItemCount { get; set; }
    // Flatten everything for fast reads (no joins)
}

public class OrderCreatedEventHandler
{
    private readonly ICosmosDbClient _cosmosDb;

    public async Task Handle(OrderCreatedEvent @event)
    {
        // Update read model in Cosmos DB
        var summary = new OrderSummary
        {
            OrderId = @event.OrderId,
            UserId = @event.UserId,
            TotalAmount = @event.TotalAmount,
            Status = "Pending",
            CreatedAt = @event.CreatedAt,
            ItemCount = @event.ItemCount
        };

        await _cosmosDb.UpsertAsync(summary);
    }
}

Shard 1: user_id 1-1,000,000     → db-shard-1
Shard 2: user_id 1,000,001-2,000,000 → db-shard-2
Shard 3: user_id 2,000,001-3,000,000 → db-shard-3

public class ShardRouter
{
    private readonly List<string> _shardConnections = new()
    {
        "Server=shard-1.database.windows.net;...",
        "Server=shard-2.database.windows.net;...",
        "Server=shard-3.database.windows.net;...",
    };

    public string GetConnectionString(string userId)
    {
        // Hash user ID to determine shard
        int hash = Math.Abs(userId.GetHashCode());
        int shardIndex = hash % _shardConnections.Count;
        return _shardConnections[shardIndex];
    }
}

// Usage
public class UserRepository
{
    private readonly ShardRouter _router;

    public async Task<User> GetUser(string userId)
    {
        string connectionString = _router.GetConnectionString(userId);

        using var connection = new SqlConnection(connectionString);
        return await connection.QuerySingleAsync<User>(
            "SELECT * FROM Users WHERE UserId = @UserId",
            new { UserId = userId }
        );
    }
}

Shard 1: tenantId IN ('company-a', 'company-b')
Shard 2: tenantId IN ('company-c', 'company-d')
Shard 3: tenantId IN ('company-e', 'company-f')

public class ProductService
{
    private readonly IDatabase _redis;
    private readonly ApplicationDbContext _db;

    public async Task<Product> GetProduct(int productId)
    {
        string cacheKey = $"product:{productId}";

        // 1. Try cache first
        string cached = await _redis.StringGetAsync(cacheKey);
        if (cached != null)
        {
            return JsonSerializer.Deserialize<Product>(cached);
        }

        // 2. Cache miss → fetch from database
        var product = await _db.Products.FindAsync(productId);
        if (product == null)
        {
            return null;
        }

        // 3. Store in cache (TTL: 1 hour)
        await _redis.StringSetAsync(
            cacheKey,
            JsonSerializer.Serialize(product),
            expiry: TimeSpan.FromHours(1)
        );

        return product;
    }
}

public async Task UpdateProduct(Product product)
{
    // 1. Update database
    _db.Products.Update(product);
    await _db.SaveChangesAsync();

    // 2. Update cache
    string cacheKey = $"product:{product.Id}";
    await _redis.StringSetAsync(
        cacheKey,
        JsonSerializer.Serialize(product),
        expiry: TimeSpan.FromHours(1)
    );
}

// Configure Redis in Azure
services.AddStackExchangeRedisCache(options =>
{
    options.Configuration = "mycache.redis.cache.windows.net:6380,password=...,ssl=True";
    options.InstanceName = "myapp:";
});

// Use distributed cache
public class OrderService
{
    private readonly IDistributedCache _cache;

    public async Task<Order> GetOrder(int orderId)
    {
        string cacheKey = $"order:{orderId}";

        // Try cache
        byte[] cached = await _cache.GetAsync(cacheKey);
        if (cached != null)
        {
            return MessagePackSerializer.Deserialize<Order>(cached);
        }

        // Fetch from DB
        var order = await _db.Orders.FindAsync(orderId);

        // Store in cache (MessagePack for efficient serialization)
        await _cache.SetAsync(
            cacheKey,
            MessagePackSerializer.Serialize(order),
            new DistributedCacheEntryOptions
            {
                AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(30)
            }
        );

        return order;
    }
}

public class OrderRepository
{
    private readonly string _primaryConnectionString;
    private readonly string _replicaConnectionString;

    public async Task<Order> GetOrder(int orderId)
    {
        // Route reads to replica
        using var connection = new SqlConnection(_replicaConnectionString);
        return await connection.QuerySingleAsync<Order>(
            "SELECT * FROM Orders WHERE OrderId = @OrderId",
            new { OrderId = orderId }
        );
    }

    public async Task CreateOrder(Order order)
    {
        // Route writes to primary
        using var connection = new SqlConnection(_primaryConnectionString);
        await connection.ExecuteAsync(
            "INSERT INTO Orders (...) VALUES (...)",
            order
        );
    }
}

# Enable read scale-out (Premium/Business Critical tiers only)
az sql db update \
  --resource-group rg-prod \
  --server myserver \
  --name mydb \
  --read-scale Enabled

Server=myserver.database.windows.net;Database=mydb;
ApplicationIntent=ReadOnly;  # Routes to replica

// Configure Cosmos DB for multi-region writes
var cosmosClient = new CosmosClient(
    accountEndpoint: "https://myaccount.documents.azure.com:443/",
    authKey: "...",
    clientOptions: new CosmosClientOptions
    {
        ApplicationRegion = Regions.EastUS,  // Primary region
        ConnectionMode = ConnectionMode.Direct,
        ConsistencyLevel = ConsistencyLevel.Session  // Session consistency
    }
);

// Write to nearest region (low latency)
await container.CreateItemAsync(order, new PartitionKey(order.UserId));

{
  "conflictResolutionPolicy": {
    "mode": "LastWriterWins",
    "conflictResolutionPath": "/_ts"
  }
}