async function processOrder(orderId: string) {
  // Need to track state for rollbacks 😫
  const reservedInventory = []

  try {
    // Get order details - with retries because production is flaky
    let order
    let retries = 3
    while (retries > 0) {
      try {
        const response = await fetch("https://your-api.com/api/orders/" + orderId)
        if (!response.ok) throw new Error(`HTTP ${response.status}`)
        order = await response.json()
        break
      } catch (e) {
        retries--
        if (retries === 0)
          throw new Error("Failed to fetch order after 3 attempts: " + e.message)
        await new Promise((r) => setTimeout(r, 1000 * (3 - retries))) // Backoff
      }
    }

    // Check inventory for all items - parallel but need to handle partial failures
    const inventoryChecks = await Promise.all(
      order.items.map(async (item, idx) => {
        try {
          const response = await fetch("https://your-api.com/api/inventory/" + item.productId)
          if (!response.ok) throw new Error(`HTTP ${response.status}`)
          const inv = await response.json()

          if (inv.quantity < item.quantity) {
            throw new Error("Insufficient inventory for " + item.productId)
          }
          return inv
        } catch (e) {
          // Should we fail everything or just this item? 🤔
          console.error(`Item ${idx + 1}/${order.items.length} check failed:`, e)
          throw new Error(`Inventory check failed for item ${item.productId}: ${e.message}`)
        }
      })
    )

    // Reserve inventory - need to track for rollback if later steps fail
    for (const [idx, item] of order.items.entries()) {
      try {
        const response = await fetch("https://your-api.com/api/inventory/" + item.productId + "/reserve", {
          method: "POST",
          body: JSON.stringify({ quantity: item.quantity })
        })

        if (!response.ok) {
          // Uh oh, need to roll back previous reservations! 😱
          for (const prevItem of reservedInventory) {
            try {
              await fetch("https://your-api.com/api/inventory/" + prevItem.productId + "/release", {
                method: "POST",
                body: JSON.stringify({ quantity: prevItem.quantity })
              })
            } catch (releaseError) {
              console.error("Failed to release inventory:", releaseError)
              // Now we're in an inconsistent state! What do we do? 😱
            }
          }
          throw new Error(`HTTP ${response.status}`)
        }

        reservedInventory.push(item)
      } catch (e) {
        throw new Error(`Failed to reserve inventory for item ${item.productId}: ${e.message}`)
      }
    }

    // Process payment - with timeout because payment APIs are slow
    const controller = new AbortController()
    const timeout = setTimeout(() => controller.abort(), 10000)

    try {
      const response = await fetch("https://your-api.com/api/payments", {
        method: "POST",
        body: JSON.stringify({
          orderId,
          amount: order.total
        }),
        signal: controller.signal
      })

      if (!response.ok) {
        throw new Error(`HTTP ${response.status}`)
      }
    } catch (e) {
      // Payment failed - need to release ALL inventory
      console.error("Payment failed, rolling back inventory reservations...")
      
      try {
        await Promise.all(reservedInventory.map(item =>
          fetch("https://your-api.com/api/inventory/" + item.productId + "/release", {
            method: "POST",
            body: JSON.stringify({ quantity: item.quantity })
          })
        ))
      } catch (releaseError) {
        console.error("Failed to release inventory after payment failure:", releaseError)
        // More inconsistent state! 🔥
      }
      
      throw new Error(`Payment failed: ${e.message}`)
    } finally {
      clearTimeout(timeout)
    }

    return { success: true, orderId }
  } catch (error) {
    // Which operation failed? What's our current state?
    // How do we recover? Where do we retry?
    // Good luck debugging this in production! 😅
    console.error("Something went wrong:", error)
    throw error
  }
}