Engineering for Growth: Building Software from MVP to Series A and Beyond

// MVP Tech Stack Example (Next.js + Supabase)
// pages/api/submit.ts
import { createClient } from '@supabase/supabase-js'

const supabase = createClient(
  process.env.SUPABASE_URL!,
  process.env.SUPABASE_ANON_KEY!
)

export default async function handler(req, res) {
  // Simple, direct implementation
  const { error } = await supabase
    .from('leads')
    .insert({ email: req.body.email })
  
  if (error) return res.status(500).json({ error })
  return res.status(200).json({ success: true })
}

// No abstraction layers
// No error handling beyond basics
// No logging infrastructure
// SHIP IT!

// Pre-Seed: Add structure and error handling
// src/services/user.service.ts
import { db } from '@/lib/database'
import { logger } from '@/lib/logger'
import { UserCreateInput, User } from '@/types'

export class UserService {
  async createUser(input: UserCreateInput): Promise<User> {
    try {
      // Validation
      if (!input.email || !this.isValidEmail(input.email)) {
        throw new ValidationError('Invalid email')
      }

      // Business logic
      const existingUser = await db.user.findUnique({
        where: { email: input.email }
      })
      
      if (existingUser) {
        throw new ConflictError('User already exists')
      }

      // Create user
      const user = await db.user.create({
        data: {
          email: input.email,
          name: input.name,
          createdAt: new Date()
        }
      })

      // Analytics
      await this.analytics.track('user_created', {
        userId: user.id,
        source: input.source
      })

      logger.info('User created', { userId: user.id })
      return user

    } catch (error) {
      logger.error('Failed to create user', { error, input })
      throw error
    }
  }

  private isValidEmail(email: string): boolean {
    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)
  }
}

// Now we have:
// - Service layer abstraction
// - Error handling
// - Logging
// - Analytics
// - Validation
// But still relatively simple

// Seed: Introduce layered architecture
// src/api/controllers/user.controller.ts
import { Request, Response } from 'express'
import { UserService } from '@/services/user.service'
import { CacheService } from '@/services/cache.service'
import { validate } from '@/middleware/validation'
import { authenticate } from '@/middleware/auth'

export class UserController {
  constructor(
    private userService: UserService,
    private cache: CacheService
  ) {}

  @authenticate()
  @validate(UpdateUserSchema)
  async updateUser(req: Request, res: Response) {
    const { userId } = req.params
    const updates = req.body

    try {
      // Check cache first
      const cacheKey = `user:${userId}`
      await this.cache.delete(cacheKey)

      // Update user
      const user = await this.userService.updateUser(userId, updates)

      // Invalidate related caches
      await this.cache.deletePattern(`user:${userId}:*`)

      // Update search index (async)
      this.searchService.indexUser(user).catch(err => 
        logger.error('Search indexing failed', { err, userId })
      )

      return res.json({ data: user })
    } catch (error) {
      if (error instanceof NotFoundError) {
        return res.status(404).json({ error: 'User not found' })
      }
      throw error
    }
  }
}

// Seed infrastructure considerations:
// - Dependency injection
// - Middleware for cross-cutting concerns
// - Async operations for non-critical paths
// - Cache invalidation strategies
// - Search indexing for discovery

// Series A: Domain-driven microservices
// services/user-service/src/domain/user.ts
import { Entity, AggregateRoot } from '@/shared/domain'
import { UserCreatedEvent, UserUpdatedEvent } from './events'

export class User extends AggregateRoot {
  private constructor(
    public readonly id: string,
    private email: string,
    private profile: UserProfile,
    private subscription: Subscription,
    private preferences: UserPreferences
  ) {
    super(id)
  }

  static create(props: UserCreateProps): User {
    const user = new User(
      generateId(),
      props.email,
      UserProfile.create(props.profile),
      Subscription.free(),
      UserPreferences.defaults()
    )
    
    user.addDomainEvent(new UserCreatedEvent(user.id, user.email))
    return user
  }

  updateSubscription(plan: SubscriptionPlan): void {
    const previousPlan = this.subscription.plan
    this.subscription = this.subscription.changePlan(plan)
    
    this.addDomainEvent(
      new SubscriptionChangedEvent(
        this.id,
        previousPlan,
        plan
      )
    )
  }

  // Domain logic encapsulated in entity
  canAccessFeature(feature: Feature): boolean {
    return this.subscription.plan.hasFeature(feature) &&
           !this.subscription.isExpired()
  }
}

// services/user-service/src/application/commands/update-user.handler.ts
export class UpdateUserCommandHandler {
  constructor(
    private userRepository: IUserRepository,
    private eventBus: IEventBus,
    private cache: ICacheService
  ) {}

  async execute(command: UpdateUserCommand): Promise<void> {
    // Load aggregate
    const user = await this.userRepository.findById(command.userId)
    if (!user) throw new UserNotFoundError(command.userId)

    // Execute domain logic
    user.updateProfile(command.profileData)

    // Persist
    await this.userRepository.save(user)

    // Publish events
    const events = user.getDomainEvents()
    await this.eventBus.publishAll(events)

    // Invalidate caches
    await this.cache.invalidate(`user:${user.id}`)
  }
}

// Event-driven communication between services
// DDD patterns for complex domain logic
// CQRS for read/write optimization
// Event sourcing for audit trails