
At Pangea, we built an event-driven architecture for our FX and payments platform. TypeScript's type system made it possible to build reliable, type-safe event handlers across multiple services.

#### Why Event-Driven?

Event-driven architecture provides:
- Loose coupling between services
- Scalability (services scale independently)
- Resilience (failures are isolated)
- Flexibility (easy to add new consumers)

#### The Architecture

We use:
- **Pub/Sub** (Google Cloud Pub/Sub) for messaging
- **TypeScript** for type safety
- **Event schemas** defined in shared packages
- **Dead letter queues** for failed events

#### Event Schema

```typescript
// Shared event types
export interface PaymentCreatedEvent {
  type: 'payment.created';
  paymentId: string;
  amount: Decimal;
  currency: CurrencyCode;
  timestamp: Date;
  metadata: Record<string, unknown>;
}

export interface PaymentFailedEvent {
  type: 'payment.failed';
  paymentId: string;
  reason: string;
  timestamp: Date;
}

export type PaymentEvent = PaymentCreatedEvent | PaymentFailedEvent;
```

#### Event Publisher

```typescript
import { PubSub } from '@google-cloud/pubsub';

class EventPublisher {
  private pubsub: PubSub;
  private topic: Topic;
  
  constructor(topicName: string) {
    this.pubsub = new PubSub();
    this.topic = this.pubsub.topic(topicName);
  }
  
  async publish<T extends PaymentEvent>(event: T): Promise<void> {
    const messageId = await this.topic.publishMessage({
      json: event,
    });
    console.log(`Published ${event.type} with ID ${messageId}`);
  }
}
```

#### Event Consumer

```typescript
class PaymentEventHandler {
  private subscription: Subscription;
  
  constructor(subscriptionName: string) {
    const pubsub = new PubSub();
    this.subscription = pubsub.subscription(subscriptionName);
  }
  
  async start(): Promise<void> {
    this.subscription.on('message', (message) => {
      const event = message.json as PaymentEvent;
      this.handleEvent(event);
      message.ack();
    });
  }
  
  private async handleEvent(event: PaymentEvent): Promise<void> {
    switch (event.type) {
      case 'payment.created':
        await this.handlePaymentCreated(event);
        break;
      case 'payment.failed':
        await this.handlePaymentFailed(event);
        break;
      default:
        console.warn(`Unknown event type: ${(event as any).type}`);
    }
  }
  
  private async handlePaymentCreated(event: PaymentCreatedEvent): Promise<void> {
    // Process payment created event
  }
  
  private async handlePaymentFailed(event: PaymentFailedEvent): Promise<void> {
    // Handle payment failure
  }
}
```

#### Benefits

- Type safety catches errors at compile time
- Easy to add new event types
- Clear contracts between services
- Better IDE support and autocomplete

#### Challenges

- Event ordering (use partitioning keys)
- Idempotency (handle duplicate events)
- Error handling (dead letter queues)
- Testing (mock event publishers)

#### Best Practices

1. Version your event schemas
2. Make events idempotent
3. Use dead letter queues
4. Monitor event processing
5. Document event contracts

> "Events are the contracts between services. Make them explicit and type-safe."



Event-driven architecture with TypeScript


At lululemon, I built a prototype for the Seawheeze community app using serverless AWS architecture. The app connected runners, tracked training progress, and built community around the annual Seawheeze half marathon.

#### Why Serverless?

Serverless provides:
- No server management
- Automatic scaling
- Pay-per-use pricing
- Fast development
- Built-in integrations

#### Architecture

We used:
- **Lambda**: Backend functions
- **API Gateway**: REST API
- **DynamoDB**: User and activity data
- **S3**: Static assets and images
- **Cognito**: Authentication
- **CloudFront**: CDN

#### Lambda Functions

```python
import json
import boto3
from decimal import Decimal

dynamodb = boto3.resource('dynamodb')
runs_table = dynamodb.Table('seawheeze-runs')

def create_run(event, context):
    """
    Create a new run entry.
    """
    body = json.loads(event['body'])
    user_id = event['requestContext']['authorizer']['userId']
    
    run = {
        'run_id': generate_id(),
        'user_id': user_id,
        'distance': Decimal(str(body['distance'])),
        'duration': body['duration'],
        'date': body['date'],
        'created_at': datetime.utcnow().isoformat(),
    }
    
    runs_table.put_item(Item=run)
    
    return {
        'statusCode': 201,
        'body': json.dumps(run),
    }

def get_user_runs(event, context):
    """
    Get runs for a user.
    """
    user_id = event['requestContext']['authorizer']['userId']
    
    response = runs_table.query(
        KeyConditionExpression='user_id = :uid',
        ExpressionAttributeValues={':uid': user_id},
        ScanIndexForward=False,
    )
    
    return {
        'statusCode': 200,
        'body': json.dumps(response['Items']),
    }
```

#### API Gateway Configuration

```yaml
# serverless.yml
service: seawheeze-app

provider:
  name: aws
  runtime: python3.9
  region: us-west-2

functions:
  createRun:
    handler: handlers.create_run
    events:
      - http:
          path: runs
          method: post
          cors: true
          authorizer: aws_iam
  
  getUserRuns:
    handler: handlers.get_user_runs
    events:
      - http:
          path: runs
          method: get
          cors: true
          authorizer: aws_iam

resources:
  Resources:
    RunsTable:
      Type: AWS::DynamoDB::Table
      Properties:
        TableName: seawheeze-runs
        BillingMode: PAY_PER_REQUEST
        AttributeDefinitions:
          - AttributeName: user_id
            AttributeType: S
          - AttributeName: run_id
            AttributeType: S
        KeySchema:
          - AttributeName: user_id
            KeyType: HASH
          - AttributeName: run_id
            KeyType: RANGE
```

#### Frontend Integration

```typescript
const API_URL = 'https://api.seawheeze.com';

async function createRun(runData: RunData): Promise<Run> {
  const response = await fetch(`${API_URL}/runs`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${getAuthToken()}`,
    },
    body: JSON.stringify(runData),
  });
  
  return response.json();
}

async function getUserRuns(userId: string): Promise<Run[]> {
  const response = await fetch(`${API_URL}/runs?userId=${userId}`, {
    headers: {
      'Authorization': `Bearer ${getAuthToken()}`,
    },
  });
  
  return response.json();
}
```

#### Benefits

- Fast development (days vs weeks)
- Low cost (pay only for usage)
- Automatic scaling
- No server management
- Easy to iterate

#### Results

- Working prototype in days
- Low infrastructure costs
- Scalable architecture
- Easy to extend
- Good performance

> "Serverless enables rapid prototyping."

#### Lessons Learned

1. Start with serverless for prototypes
2. Use managed services when possible
3. Monitor Lambda costs
4. Optimize cold starts
5. Plan for production scaling



Building a serverless prototype for Seawheeze community app


At Elevate Security, we launched real-time analytics (RDRs - Real-time Data Reports) that provided instant insights into security events. The system processed thousands of events per second and displayed results in a React dashboard.

#### The Challenge

Security events happen in real-time, and delayed insights mean delayed responses. We needed:
- Sub-second latency
- High throughput (thousands of events/second)
- Real-time visualization
- Historical context
- Alerting capabilities

#### Architecture

We built:
- **Event ingestion**: Kafka for event streaming
- **Processing**: Real-time aggregation with Apache Flink
- **Storage**: Time-series database (InfluxDB)
- **API**: FastAPI for data access
- **Frontend**: React with real-time updates

#### Event Processing

```typescript
interface SecurityEvent {
  timestamp: Date;
  eventType: string;
  userId: string;
  ipAddress: string;
  severity: 'low' | 'medium' | 'high' | 'critical';
  metadata: Record<string, unknown>;
}

class RealTimeAnalytics {
  private eventStream: EventStream;
  private aggregator: EventAggregator;
  
  async processEvent(event: SecurityEvent): Promise<void> {
    // Update real-time counters
    await this.aggregator.incrementCounter(
      `events.${event.eventType}`,
      event.timestamp
    );
    
    // Update user activity
    await this.aggregator.updateUserActivity(
      event.userId,
      event.timestamp
    );
    
    // Check for anomalies
    if (await this.detectAnomaly(event)) {
      await this.triggerAlert(event);
    }
    
    // Update dashboard
    await this.broadcastUpdate(event);
  }
}
```

#### Real-Time Dashboard

```typescript
import { useEffect, useState } from 'react';
import useWebSocket from 'react-use-websocket';

function RealTimeDashboard() {
  const [metrics, setMetrics] = useState<Metrics>({});
  const { lastMessage } = useWebSocket('ws://api/events/stream');
  
  useEffect(() => {
    if (lastMessage) {
      const update = JSON.parse(lastMessage.data);
      setMetrics(prev => ({
        ...prev,
        ...update,
      }));
    }
  }, [lastMessage]);
  
  return (
    <div>
      <MetricCard label="Events/sec" value={metrics.eventsPerSecond} />
      <MetricCard label="Active Users" value={metrics.activeUsers} />
      <EventTimeline events={metrics.recentEvents} />
    </div>
  );
}
```

#### Aggregation Logic

```typescript
class EventAggregator {
  private counters: Map<string, number> = new Map();
  private timeWindows: Map<string, TimeWindow> = new Map();
  
  incrementCounter(key: string, timestamp: Date): void {
    const windowKey = this.getTimeWindow(timestamp);
    const current = this.counters.get(windowKey) || 0;
    this.counters.set(windowKey, current + 1);
  }
  
  getMetrics(timeRange: TimeRange): Metrics {
    const relevantWindows = this.getWindowsInRange(timeRange);
    
    return {
      totalEvents: relevantWindows.reduce((sum, w) => sum + w.count, 0),
      eventsPerSecond: this.calculateRate(relevantWindows),
      topEventTypes: this.getTopEventTypes(relevantWindows),
    };
  }
}
```

#### Performance Optimization

- Use time-windowed aggregation
- Cache frequently accessed metrics
- Batch database writes
- Use WebSockets for real-time updates
- Optimize queries with indexes

#### Results

- Sub-second latency for metrics
- Real-time visualization
- Better security incident response
- Improved user experience
- Scalable to millions of events

> "Real-time analytics enable faster decision-making."

#### Lessons Learned

1. Choose the right time-series database
2. Optimize aggregation queries
3. Use WebSockets for real-time updates
4. Handle backpressure gracefully
5. Monitor system performance



Building real-time analytics with RDRs


At Skillshare, we migrated our payments backend to Nest.js and our frontend to React. The migration improved developer experience, type safety, and maintainability.

#### Why Migrate?

Our legacy stack had issues:
- Tight coupling between components
- Limited type safety
- Difficult to test
- Poor developer experience
- Hard to scale

#### Backend: Nest.js Migration

Nest.js provides:
- TypeScript-first architecture
- Dependency injection
- Modular structure
- Built-in testing support
- Excellent documentation

#### Service Structure

```typescript
// payment.service.ts
@Injectable()
export class PaymentService {
  constructor(
    private paymentRepository: PaymentRepository,
    private notificationService: NotificationService,
  ) {}
  
  async processPayment(dto: CreatePaymentDto): Promise<Payment> {
    const payment = await this.paymentRepository.create(dto);
    await this.notificationService.sendConfirmation(payment);
    return payment;
  }
}

// payment.controller.ts
@Controller('payments')
export class PaymentController {
  constructor(private paymentService: PaymentService) {}
  
  @Post()
  async create(@Body() dto: CreatePaymentDto): Promise<Payment> {
    return this.paymentService.processPayment(dto);
  }
}
```

#### Module Organization

```typescript
@Module({
  imports: [TypeOrmModule.forFeature([Payment])],
  controllers: [PaymentController],
  providers: [PaymentService, PaymentRepository],
  exports: [PaymentService],
})
export class PaymentModule {}
```

#### Frontend: React Migration

React provides:
- Component-based architecture
- Strong ecosystem
- TypeScript support
- Great developer tools
- Performance optimizations

#### Component Structure

```typescript
interface PaymentFormProps {
  onSubmit: (payment: PaymentData) => void;
}

function PaymentForm({ onSubmit }: PaymentFormProps) {
  const [paymentData, setPaymentData] = useState<PaymentData>({
    amount: 0,
    currency: 'USD',
  });
  
  const handleSubmit = (e: React.FormEvent) => {
    e.preventDefault();
    onSubmit(paymentData);
  };
  
  return (
    <form onSubmit={handleSubmit}>
      <input
        type="number"
        value={paymentData.amount}
        onChange={(e) => setPaymentData({
          ...paymentData,
          amount: parseFloat(e.target.value),
        })}
      />
      <button type="submit">Pay</button>
    </form>
  );
}
```

#### Migration Strategy

1. **Parallel Run**: Run old and new systems side-by-side
2. **Feature Flags**: Gradually enable new system
3. **Incremental Migration**: Move features one at a time
4. **Testing**: Comprehensive testing at each step
5. **Rollback Plan**: Ability to revert if needed

#### Testing

```typescript
// Backend tests
describe('PaymentService', () => {
  let service: PaymentService;
  
  beforeEach(async () => {
    const module = await Test.createTestingModule({
      providers: [PaymentService, PaymentRepository],
    }).compile();
    
    service = module.get<PaymentService>(PaymentService);
  });
  
  it('should process payment', async () => {
    const result = await service.processPayment({
      amount: 100,
      currency: 'USD',
    });
    
    expect(result).toBeDefined();
  });
});

// Frontend tests
describe('PaymentForm', () => {
  it('should submit payment data', () => {
    const onSubmit = jest.fn();
    render(<PaymentForm onSubmit={onSubmit} />);
    
    fireEvent.change(screen.getByLabelText('Amount'), {
      target: { value: '100' },
    });
    fireEvent.click(screen.getByText('Pay'));
    
    expect(onSubmit).toHaveBeenCalledWith({
      amount: 100,
      currency: 'USD',
    });
  });
});
```

#### Results

- Better type safety
- Improved developer experience
- Easier testing
- More maintainable code
- Faster feature development

> "Modern frameworks improve productivity and code quality."

#### Lessons Learned

1. Plan migration carefully
2. Test thoroughly
3. Migrate incrementally
4. Train team on new stack
5. Monitor performance



Migrating to Nest.js and React


At Pangea, we built event-driven ingestion pipelines using Pub/Sub, Cloud Run, and event sourcing patterns. The system processes financial events reliably and scales automatically.

#### Architecture

```typescript
// Event publisher
class EventPublisher {
  private pubsub: PubSub;
  
  async publishEvent(event: FinancialEvent): Promise<void> {
    const topic = this.pubsub.topic('financial-events');
    await topic.publishMessage({
      json: event,
      attributes: {
        eventType: event.type,
        userId: event.userId,
      },
    });
  }
}

// Event consumer
class EventConsumer {
  private subscription: Subscription;
  
  async start(): Promise<void> {
    this.subscription.on('message', async (message) => {
      try {
        const event = message.json as FinancialEvent;
        await this.processEvent(event);
        message.ack();
      } catch (error) {
        logger.error('Failed to process event', error);
        message.nack();
      }
    });
  }
  
  private async processEvent(event: FinancialEvent): Promise<void> {
    switch (event.type) {
      case 'payment.created':
        await this.handlePaymentCreated(event);
        break;
      case 'transaction.completed':
        await this.handleTransactionCompleted(event);
        break;
      // ... more handlers
    }
  }
}
```

#### Event Sourcing

```typescript
interface Event {
  id: string;
  type: string;
  aggregateId: string;
  data: Record<string, unknown>;
  timestamp: Date;
  version: number;
}

class EventStore {
  async append(aggregateId: string, events: Event[]): Promise<void> {
    // Store events in order
    for (const event of events) {
      await this.store.append(aggregateId, event);
    }
  }
  
  async getEvents(aggregateId: string): Promise<Event[]> {
    return this.store.getEvents(aggregateId);
  }
  
  async replay(aggregateId: string): Promise<AggregateState> {
    const events = await this.getEvents(aggregateId);
    return events.reduce((state, event) => this.applyEvent(state, event), initialState);
  }
}
```

#### Benefits

- Reliable processing
- Automatic scaling
- Event replay capability
- Audit trail
- Loose coupling

> "Event-driven architecture enables reliable, scalable systems."

#### Lessons Learned

1. Design events carefully
2. Handle idempotency
3. Implement proper error handling
4. Monitor event processing
5. Plan for event replay



Event-driven data ingestion at Pangea


At Skillshare, we scaled payments globally by building a decoupled checkout architecture. This allowed us to add new payment providers without modifying core checkout code, supporting 13 new providers across different regions.

#### The Problem

Our original checkout was tightly coupled to Stripe:
- Adding new providers required code changes
- Different regions needed different providers
- Testing was difficult
- Hard to A/B test providers

#### The Solution

We built a decoupled architecture:
- **Checkout service**: Handles UI and user flow
- **Payment abstraction layer**: Provider-agnostic interface
- **Provider adapters**: Implementations for each provider
- **Routing logic**: Select provider based on region/user
- **Unified webhooks**: Normalize provider callbacks

#### Architecture

```typescript
interface PaymentProvider {
  createPaymentIntent(amount: number, currency: string): Promise<PaymentIntent>;
  confirmPayment(paymentId: string): Promise<PaymentResult>;
  handleWebhook(payload: unknown): Promise<WebhookEvent>;
}

class StripeProvider implements PaymentProvider {
  async createPaymentIntent(amount: number, currency: string) {
    const intent = await stripe.paymentIntents.create({
      amount,
      currency,
    });
    return this.normalizePaymentIntent(intent);
  }
}

class PayPalProvider implements PaymentProvider {
  async createPaymentIntent(amount: number, currency: string) {
    const order = await paypal.orders.create({
      purchase_units: [{
        amount: { value: amount.toString(), currency_code: currency },
      }],
    });
    return this.normalizePaymentIntent(order);
  }
}
```

#### Provider Router

```typescript
class PaymentProviderRouter {
  private providers: Map<string, PaymentProvider>;
  
  constructor() {
    this.providers = new Map([
      ['stripe', new StripeProvider()],
      ['paypal', new PayPalProvider()],
      ['adyen', new AdyenProvider()],
      // ... more providers
    ]);
  }
  
  selectProvider(user: User, amount: number, currency: string): PaymentProvider {
    // Route based on region
    if (user.region === 'US') {
      return this.providers.get('stripe');
    } else if (user.region === 'EU') {
      return this.providers.get('adyen');
    } else if (user.region === 'APAC') {
      return this.providers.get('paypal');
    }
    
    // Default fallback
    return this.providers.get('stripe');
  }
}
```

#### Checkout Service

```typescript
class CheckoutService {
  private router: PaymentProviderRouter;
  
  async initiateCheckout(user: User, cart: Cart): Promise<CheckoutSession> {
    const provider = this.router.selectProvider(
      user,
      cart.total,
      cart.currency
    );
    
    const paymentIntent = await provider.createPaymentIntent(
      cart.total,
      cart.currency
    );
    
    return {
      sessionId: generateId(),
      paymentIntentId: paymentIntent.id,
      provider: provider.name,
      clientSecret: paymentIntent.clientSecret,
    };
  }
  
  async confirmPayment(sessionId: string, paymentMethod: PaymentMethod): Promise<PaymentResult> {
    const session = await this.getSession(sessionId);
    const provider = this.router.getProvider(session.provider);
    
    return await provider.confirmPayment(
      session.paymentIntentId,
      paymentMethod
    );
  }
}
```

#### Webhook Normalization

```typescript
class WebhookHandler {
  async handleWebhook(provider: string, payload: unknown): Promise<void> {
    const providerImpl = this.router.getProvider(provider);
    const event = await providerImpl.handleWebhook(payload);
    
    // Normalize to common event format
    const normalizedEvent = this.normalizeEvent(event);
    
    // Process event
    await this.processEvent(normalizedEvent);
  }
  
  private normalizeEvent(event: ProviderWebhookEvent): NormalizedEvent {
    return {
      type: this.mapEventType(event.type),
      paymentId: event.paymentId,
      status: this.mapStatus(event.status),
      amount: event.amount,
      timestamp: event.timestamp,
    };
  }
}
```

#### Benefits

- Easy to add new providers
- Region-specific routing
- A/B testing capabilities
- Better error handling
- Unified monitoring

#### Results

- Added 13 new payment providers
- Expanded to new regions
- Improved conversion rates
- Better user experience
- Reduced checkout friction

> "Decoupling enables flexibility and scale."

#### Lessons Learned

1. Design for extensibility from the start
2. Normalize provider differences
3. Test with multiple providers
4. Monitor provider performance
5. Have fallback providers



Scaling payments globally with decoupled checkout


At Cloudentity, I built customer identity and access management (CIAM) products for Fortune 500 clients. The systems handled authentication, authorization, and user management at scale using Scala and React.

#### The Challenge

CIAM systems must:
- Scale to millions of users
- Support multiple authentication methods
- Provide fine-grained authorization
- Comply with security standards
- Integrate with existing systems

#### Architecture

We built:
- **Authentication Service**: Handle logins, SSO, MFA
- **Authorization Engine**: Policy-based access control
- **User Management**: CRUD operations for users
- **Session Management**: Token generation and validation
- **Admin Console**: React-based management UI

#### Authentication Service (Scala)

```scala
import akka.http.scaladsl.server.Directives._
import akka.http.scaladsl.model.StatusCodes

class AuthenticationService {
  def authenticate(credentials: Credentials): Future[AuthResult] = {
    credentials match {
      case UsernamePassword(username, password) =>
        authenticatePassword(username, password)
      case Token(token) =>
        validateToken(token)
      case SAMLAssertion(assertion) =>
        validateSAMLAssertion(assertion)
    }
  }
  
  private def authenticatePassword(
    username: String,
    password: String
  ): Future[AuthResult] = {
    for {
      user <- userRepository.findByUsername(username)
      isValid <- passwordService.verify(password, user.passwordHash)
    } yield {
      if (isValid) {
        val token = tokenService.generate(user)
        AuthResult.Success(token, user)
      } else {
        AuthResult.Failure("Invalid credentials")
      }
    }
  }
}
```

#### Authorization Engine

```scala
case class Policy(
  subject: String,
  resource: String,
  action: String,
  conditions: List[Condition]
)

class AuthorizationEngine {
  def authorize(
    user: User,
    resource: String,
    action: String
  ): Future[Boolean] = {
    val policies = policyRepository.findBySubject(user.id)
    
    policies.foldLeft(Future.successful(false)) { (acc, policy) =>
      acc.flatMap { authorized =>
        if (authorized) Future.successful(true)
        else evaluatePolicy(policy, user, resource, action)
      }
    }
  }
  
  private def evaluatePolicy(
    policy: Policy,
    user: User,
    resource: String,
    action: String
  ): Future[Boolean] = {
    val matchesResource = policy.resource == resource || 
                         matchesPattern(policy.resource, resource)
    val matchesAction = policy.action == action || 
                       policy.action == "*"
    val conditionsMet = policy.conditions.forall(_.evaluate(user))
    
    Future.successful(matchesResource && matchesAction && conditionsMet)
  }
}
```

#### React Admin Console

```typescript
function UserManagement() {
  const [users, setUsers] = useState<User[]>([]);
  
  useEffect(() => {
    fetchUsers().then(setUsers);
  }, []);
  
  const createUser = async (userData: CreateUserData) => {
    const user = await api.post('/users', userData);
    setUsers(prev => [...prev, user]);
  };
  
  const updateUser = async (userId: string, updates: UserUpdates) => {
    const user = await api.put(`/users/${userId}`, updates);
    setUsers(prev => prev.map(u => u.id === userId ? user : u));
  };
  
  return (
    <div>
      <UserList users={users} />
      <CreateUserForm onSubmit={createUser} />
    </div>
  );
}
```

#### Security Considerations

- Encrypt sensitive data
- Use secure token storage
- Implement rate limiting
- Log all authentication attempts
- Regular security audits

#### Results

- Scalable to millions of users
- Support for multiple auth methods
- Fine-grained authorization
- Compliance with standards
- Successful Fortune 500 deployments

> "CIAM systems are critical infrastructure."

#### Lessons Learned

1. Security must be built in from the start
2. Scalability requires careful design
3. Policy-based authorization is powerful
4. Good UX is essential for adoption
5. Compliance is non-negotiable



Building customer identity and access management at Cloudentity


At lululemon, I led the API-layer team that launched Buy Online, Pick-Up In Store (BOPIS). This feature required real-time inventory synchronization, store location services, and seamless checkout integration.

#### The Challenge

BOPIS requires:
- Real-time inventory visibility
- Store location and availability
- Seamless checkout flow
- Order management system
- Customer notifications

#### Architecture

We built:
- **Inventory API**: Real-time store inventory
- **Location Service**: Store finder and availability
- **Order API**: Create and manage pickup orders
- **Notification Service**: Customer updates
- **Store Integration**: Connect with POS systems

#### Inventory Synchronization

```typescript
class StoreInventoryService {
  async getStoreInventory(
    productId: string,
    storeId: string
  ): Promise<InventoryStatus> {
    // Check cache first
    const cached = await this.cache.get(`inventory:${storeId}:${productId}`);
    if (cached) {
      return cached;
    }
    
    // Fetch from store system
    const inventory = await this.storeSystem.getInventory(storeId, productId);
    
    // Cache for 5 minutes
    await this.cache.set(
      `inventory:${storeId}:${productId}`,
      inventory,
      300
    );
    
    return inventory;
  }
  
  async reserveInventory(
    productId: string,
    storeId: string,
    quantity: number
  ): Promise<ReservationResult> {
    // Reserve inventory in store system
    const reservation = await this.storeSystem.reserve(
      storeId,
      productId,
      quantity
    );
    
    // Invalidate cache
    await this.cache.delete(`inventory:${storeId}:${productId}`);
    
    return reservation;
  }
}
```

#### Store Location Service

```typescript
interface Store {
  id: string;
  name: string;
  address: Address;
  coordinates: Coordinates;
  hours: StoreHours;
  inventory: Map<string, number>;
}

class StoreLocationService {
  async findNearbyStores(
    location: Coordinates,
    radius: number
  ): Promise<Store[]> {
    const stores = await this.storeRepository.findNearby(location, radius);
    
    return stores.map(store => ({
      ...store,
      distance: this.calculateDistance(location, store.coordinates),
    })).sort((a, b) => a.distance - b.distance);
  }
  
  async getStoresWithProduct(
    productId: string,
    location: Coordinates
  ): Promise<Store[]> {
    const stores = await this.findNearbyStores(location, 25); // 25 miles
    
    const availableStores = await Promise.all(
      stores.map(async (store) => {
        const inventory = await this.inventoryService.getStoreInventory(
          productId,
          store.id
        );
        return inventory.available > 0 ? store : null;
      })
    );
    
    return availableStores.filter(Boolean) as Store[];
  }
}
```

#### Order Creation

```typescript
class BOPISOrderService {
  async createPickupOrder(
    customerId: string,
    items: CartItem[],
    storeId: string
  ): Promise<PickupOrder> {
    // Validate store availability
    for (const item of items) {
      const inventory = await this.inventoryService.getStoreInventory(
        item.productId,
        storeId
      );
      
      if (inventory.available < item.quantity) {
        throw new InsufficientInventoryError(item.productId, storeId);
      }
    }
    
    // Reserve inventory
    const reservations = await Promise.all(
      items.map(item =>
        this.inventoryService.reserveInventory(
          item.productId,
          storeId,
          item.quantity
        )
      )
    );
    
    // Create order
    const order = await this.orderRepository.create({
      customerId,
      storeId,
      items,
      type: 'pickup',
      status: 'pending',
      reservations: reservations.map(r => r.id),
    });
    
    // Send notifications
    await this.notificationService.sendOrderConfirmation(order);
    
    return order;
  }
}
```

#### Results

- Successful BOPIS launch
- Real-time inventory accuracy
- Seamless customer experience
- Increased store foot traffic
- Better inventory utilization

> "BOPIS bridges online and physical retail."

#### Lessons Learned

1. Real-time inventory is critical
2. Cache aggressively but invalidate properly
3. Handle inventory conflicts gracefully
4. Provide clear customer communication
5. Monitor store fulfillment rates

