// Bad: Mixed concerns
const createOrder = async (orderData: OrderInput) => {
  // Validation, business logic, persistence, and notification all mixed
  if (!orderData.items.length) throw new Error('No items');
  const total = orderData.items.reduce((sum, i) => sum + i.price, 0);
  await db.orders.insert({ ...orderData, total });
  await sendEmail(orderData.customerEmail, 'Order confirmed');
  await updateInventory(orderData.items);
  return { success: true };
};

// Good: Separated concerns
const createOrder = async (orderData: OrderInput) => {
  const validatedOrder = validateOrder(orderData);           // Validation layer
  const order = OrderService.create(validatedOrder);          // Domain layer
  await OrderRepository.save(order);                          // Persistence layer
  await EventBus.publish(new OrderCreatedEvent(order));       // Event layer
  return order;
};

// Resilient service call with retry and circuit breaker
const fetchUserData = async (userId: string) => {
  return withCircuitBreaker(
    () => withRetry(
      () => userService.getById(userId),
      { maxRetries: 3, backoff: 'exponential' }
    ),
    { failureThreshold: 5, resetTimeout: 30000 }
  );
};

# ADR-001: Choose Microservices Architecture

## Status
Accepted

## Context
Our monolithic application is experiencing scaling issues 
and deployment bottlenecks with 50+ developers.

## Decision
Migrate to microservices architecture with domain-driven boundaries.

## Consequences
- **Positive**: Independent scaling, team autonomy, technology flexibility
- **Negative**: Increased operational complexity, network latency
- **Risks**: Data consistency challenges, debugging difficulty