// Result Pattern Implementation
          type Result<T, E> = Success<T> | Failure<E>;
          
          class Success<T> {
            constructor(public value: T) {}
            isSuccess(): this is Success<T> { return true; }
            isFailure(): this is Failure<any> { return false; }
          }
          
          class Failure<E> {
            constructor(public error: E) {}
            isSuccess(): this is Success<any> { return false; }
            isFailure(): this is Failure<E> { return true; }
          }
          
          // Usage Example
          async function validateAndProcessUser(userData: UserData): Promise<Result<User, ValidationError>> {
            const validationResult = validateUser(userData);
            
            if (validationResult.isFailure()) {
              return new Failure(validationResult.error);
            }

            const user = await createUser(validationResult.value);
            return new Success(user);
          }

src/
          ├── UserManagement/
          │   ├── Domain/
          │   │   └── User.cs
          │   ├── Application/
          │   │   ├── CreateUserUseCase.cs
          │   │   └── IUserRepository.cs
          │   ├── Infrastructure/
          │   │   └── SqlUserRepository.cs
          │   └── Interface/
          │       └── UserController.cs
          ├── Orders/
          │   ├── Domain/
          │   ├── Application/
          │   ├── Infrastructure/
          │   └── Interface/
          

class Order {
            constructor(
              private customerId: CustomerId,
              private items: OrderItem[],
              private status: OrderStatus = OrderStatus.Pending
            ) {}
          
            calculateTotal(): Money {
              return this.items.reduce(
                (total, item) => total.add(item.getSubtotal()),
                Money.zero()
              );
            }
          
            canBeShipped(): boolean {
              return this.status === OrderStatus.Confirmed &&
                     this.hasShippableItems();
            }
          
            private hasShippableItems(): boolean {
              return this.items.length > 0;
            }
          }

class PlaceOrderUseCase {
            constructor(
              private orderRepository: OrderRepository,
              private paymentService: PaymentService,
              private inventoryService: InventoryService
            ) {}
          
            async execute(command: PlaceOrderCommand): Promise<Result<OrderId, OrderError>> {
              // 1. Validate inventory
              const inventoryCheck = await this.inventoryService.checkAvailability(command.items);
              if (inventoryCheck.isFailure()) {
                return new Failure(new InsufficientInventoryError());
              }
          
              // 2. Create order
              const order = new Order(command.customerId, command.items);
          
              // 3. Process payment
              const paymentResult = await this.paymentService.charge(
                command.paymentMethod,
                order.calculateTotal()
              );
          
              if (paymentResult.isFailure()) {
                return new Failure(new PaymentFailedError());
              }
          
              // 4. Save order
              const savedOrder = await this.orderRepository.save(order);
              return new Success(savedOrder.id);
            }
          }

      public class UserService
      {
          public async Task<bool> ProcessUserRegistration(
              string email, string password, string firstName, string lastName)
          {
              // Validation mixed with business logic
              if (string.IsNullOrEmpty(email) || !email.Contains("@"))
                  return false;
              if (password.Length < 8)
                  return false;
      
              // Direct database access
              using var connection = new SqlConnection(connectionString);
              var existingUser = await connection
                  .QueryFirstOrDefaultAsync<User>("SELECT * FROM Users WHERE Email = @Email", new { email });
      
              if (existingUser != null)
                  return false;
      
              var hashedPassword = HashPassword(password);
              var user = new User
              {
                  Email = email,
                  PasswordHash = hashedPassword,
                  FirstName = firstName,
                  LastName = lastName
              };
      
              await connection.ExecuteAsync(
                  "INSERT INTO Users (Email, PasswordHash, FirstName, LastName) VALUES (@Email, @PasswordHash, @FirstName, @LastName)",
                  user);
      
              return true;
          }
      
          private string HashPassword(string password)
          {
              // Basic hashing (not secure in real-world apps)
              return Convert.ToBase64String(Encoding.UTF8.GetBytes(password));
          }
      }
      

      // Separation of concerns with services and validation
      public class UserRegistrationService
      {
          private readonly IUserRepository _userRepository;
          private readonly IPasswordHasher _passwordHasher;
          private readonly IValidator<RegisterUserRequest> _validator;
      
          public UserRegistrationService(
              IUserRepository userRepository,
              IPasswordHasher passwordHasher,
              IValidator<RegisterUserRequest> validator)
          {
              _userRepository = userRepository;
              _passwordHasher = passwordHasher;
              _validator = validator;
          }
      
          public async Task<Result> RegisterUserAsync(RegisterUserRequest request)
          {
              var validationResult = _validator.Validate(request);
              if (!validationResult.IsValid)
                  return Result.Failure("Invalid input");
      
              if (await _userRepository.ExistsByEmailAsync(request.Email))
                  return Result.Failure("Email already in use");
      
              var hashedPassword = _passwordHasher.Hash(request.Password);
      
              var user = new User(
                  request.Email,
                  hashedPassword,
                  request.FirstName,
                  request.LastName);
      
              await _userRepository.AddAsync(user);
      
              return Result.Success();
          }
      }
      

// Legacy Code: Hard to test, tightly coupled
          public class OrderProcessor {
              public void processOrder(String orderId) {
                  // Direct database access
                  Connection conn = DriverManager.getConnection("jdbc:...");
                  // ... 50 lines of mixed business logic and infrastructure
                  
                  // Direct email sending
                  EmailService.sendConfirmation(order.getCustomerEmail());
              }
          }
          
          // Refactored: Testable, single responsibility
          public class OrderProcessor {
              private final OrderRepository orderRepository;
              private final NotificationService notificationService;
          
              public OrderProcessor(OrderRepository orderRepository, 
                                    NotificationService notificationService) {
                  this.orderRepository = orderRepository;
                  this.notificationService = notificationService;
              }
          
              public void processOrder(OrderId orderId) {
                  Order order = orderRepository.findById(orderId);
                  order.markAsProcessed();
                  orderRepository.save(order);
          
                  notificationService.sendOrderConfirmation(order);
              }
          }
          

// Clean Service Interface Design
          interface PaymentService {
            processPayment(request: PaymentRequest): Promise<Result<PaymentResult, PaymentError>>;
            refundPayment(paymentId: PaymentId): Promise<Result<RefundResult, RefundError>>;
            getPaymentStatus(paymentId: PaymentId): Promise<PaymentStatus>;
          }
          
          // Implementation handles all the complexity
          class StripePaymentService implements PaymentService {
            async processPayment(request: PaymentRequest): Promise<Result<PaymentResult, PaymentError>> {
              try {
                const stripeResult = await this.stripeClient.charges.create({
                  amount: request.amount.toCents(),
                  currency: request.currency.code,
                  source: request.paymentMethod.token,
                });
          
                return new Success(PaymentResult.fromStripeCharge(stripeResult));
              } catch (error) {
                return new Failure(PaymentError.fromStripeError(error));
              }
            }
          }
          

              // Secure by Design
              class UserService {
                  private readonly passwordHasher: PasswordHasher;
                  private readonly auditLogger: AuditLogger;
                  private readonly userRepository: UserRepository;
              
                  constructor(
                      passwordHasher: PasswordHasher,
                      auditLogger: AuditLogger,
                      userRepository: UserRepository
                  ) {
                      this.passwordHasher = passwordHasher;
                      this.auditLogger = auditLogger;
                      this.userRepository = userRepository;
                  }
              
                  async authenticateUser(credentials: LoginCredentials): Promise<Result<User, AuthError>> {
                      // Input validation at boundary
                      const validationResult = this.validateCredentials(credentials);
                      if (validationResult.isFailure()) {
                          this.auditLogger.logFailedLogin(credentials.username, 'Invalid format');
                          return new Failure(new InvalidCredentialsError());
                      }
              
                      const user = await this.userRepository.findByUsername(credentials.username);
                      if (!user) {
                          // Constant-time response to prevent username enumeration
                          await this.passwordHasher.hash('dummy-password');
                          this.auditLogger.logFailedLogin(credentials.username, 'User not found');
                          return new Failure(new InvalidCredentialsError());
                      }
              
                      const isValidPassword = await this.passwordHasher.verify(
                          credentials.password,
                          user.hashedPassword
                      );
              
                      if (!isValidPassword) {
                          this.auditLogger.logFailedLogin(credentials.username, 'Invalid password');
                          return new Failure(new InvalidCredentialsError());
                      }
              
                      this.auditLogger.logSuccessfulLogin(user.id);
                      return new Success(user);
                  }
              
                  private validateCredentials(credentials: LoginCredentials): Result<void, ValidationError> {
                      // Validation logic here
                  }
              }
              

# ADR-001: Use Result Pattern for Error Handling
          
          ## Status
          Accepted
          
          ## Context
          Our current exception-based error handling makes it difficult to distinguish 
          between expected business failures and unexpected technical failures.
          
          ## Decision
          We will use the Result<T, E> pattern for operations that can fail in expected ways.
          
          ## Consequences
          - Positive: Explicit error handling, better API contracts
          - Positive: Easier to test error scenarios
          - Negative: More verbose than exceptions
          - Negative: Learning curve for team members
          

// Extensible Design Example
          interface NotificationChannel {
            send(message: NotificationMessage): Promise>;
            supports(type: NotificationType): boolean;
          }
          
          class NotificationService {
            private channels = new Map();
          
            registerChannel(name: string, channel: NotificationChannel): void {
              this.channels.set(name, channel);
            }
          
            async sendNotification(message: NotificationMessage): Promise {
              const availableChannels = Array.from(this.channels.values())
                .filter(channel => channel.supports(message.type));
          
              if (availableChannels.length === 0) {
                throw new Error(`No channel supports ${message.type}`);
              }
          
              // Try channels in priority order
              for (const channel of availableChannels) {
                const result = await channel.send(message);
                if (result.isSuccess()) {
                  return;
                }
              }
          
              throw new Error('All notification channels failed');
            }
          }
          
          // Adding new channels is easy - no modification of existing code
          notificationService.registerChannel('slack', new SlackChannel(config));
          notificationService.registerChannel('discord', new DiscordChannel(config));