bradtaylorsf System Design Patterns Skill
Common patterns for designing scalable systems.
Architectural Patterns
Layered Architecture
┌─────────────────────────────┐
│ Presentation Layer │ UI, API endpoints
├─────────────────────────────┤
│ Application Layer │ Business logic, use cases
├─────────────────────────────┤
│ Domain Layer │ Entities, business rules
├─────────────────────────────┤
│ Infrastructure Layer │ Database, external services
└─────────────────────────────┘
// Presentation Layer
@Controller('users')
class UserController {
constructor(private userService: UserService) {}
@Get(':id')
getUser(@Param('id') id: string) {
return this.userService.findById(id)
}
}
// Application Layer
class UserService {
constructor(private userRepository: UserRepository) {}
async findById(id: string): Promise<User> {
return this.userRepository.findById(id)
}
}
// Domain Layer
class User {
constructor(
public id: string,
public email: string,
public name: string
) {}
updateEmail(newEmail: string) {
// Business validation
if (!this.isValidEmail(newEmail)) {
throw new ValidationError('Invalid email')
}
this.email = newEmail
}
}
// Infrastructure Layer
class TypeOrmUserRepository implements UserRepository {
async findById(id: string): Promise<User | null> {
return this.repository.findOne({ where: { id } })
}
}
Microservices
┌─────────────┐
│ API Gateway │
└──────┬──────┘
┌───────────────┼───────────────┐
▼ ▼ ▼
┌────────────┐ ┌────────────┐ ┌────────────┐
│ User │ │ Order │ │ Payment │
│ Service │ │ Service │ │ Service │
└────────────┘ └────────────┘ └────────────┘
│ │ │
▼ ▼ ▼
┌────────────┐ ┌────────────┐ ┌────────────┐
│ User DB │ │ Order DB │ │ Payment DB │
└────────────┘ └────────────┘ └────────────┘
Event-Driven Architecture
// Event definition
interface OrderCreatedEvent {
orderId: string
userId: string
items: OrderItem[]
total: number
createdAt: Date
}
// Publisher
class OrderService {
async createOrder(data: CreateOrderDTO): Promise<Order> {
const order = await this.repository.save(data)
await this.eventBus.publish('order.created', {
orderId: order.id,
userId: order.userId,
items: order.items,
total: order.total,
createdAt: order.createdAt
})
return order
}
}
// Subscribers
class InventoryService {
@OnEvent('order.created')
async reserveInventory(event: OrderCreatedEvent) {
for (const item of event.items) {
await this.inventory.reserve(item.productId, item.quantity)
}
}
}
class NotificationService {
@OnEvent('order.created')
async sendConfirmation(event: OrderCreatedEvent) {
const user = await this.userService.findById(event.userId)
await this.email.send(user.email, 'Order Confirmation', { order: event })
}
}
Data Patterns
CQRS (Command Query Responsibility Segregation)
// Commands (Write side)
class CreateUserCommand {
constructor(public email: string, public name: string) {}
}
class CreateUserHandler {
async execute(command: CreateUserCommand) {
const user = new User(uuid(), command.email, command.name)
await this.writeRepository.save(user)
await this.eventBus.publish(new UserCreatedEvent(user))
}
}
// Queries (Read side)
class GetUserQuery {
constructor(public userId: string) {}
}
class GetUserHandler {
async execute(query: GetUserQuery) {
return this.readRepository.findById(query.userId)
}
}
// Read model updated by events
class UserProjection {
@OnEvent('user.created')
async onUserCreated(event: UserCreatedEvent) {
await this.readModel.insert({
id: event.userId,
email: event.email,
name: event.name,
createdAt: event.createdAt
})
}
}
Event Sourcing
// Events are the source of truth
interface Event {
id: string
aggregateId: string
type: string
data: any
timestamp: Date
version: number
}
// Account aggregate
class Account {
private balance: number = 0
private events: Event[] = []
deposit(amount: number) {
this.apply(new MoneyDepositedEvent(this.id, amount))
}
withdraw(amount: number) {
if (this.balance < amount) {
throw new InsufficientFundsError()
}
this.apply(new MoneyWithdrawnEvent(this.id, amount))
}
// Rebuild state from events
static fromEvents(events: Event[]): Account {
const account = new Account()
for (const event of events) {
account.applyEvent(event)
}
return account
}
private applyEvent(event: Event) {
switch (event.type) {
case 'MoneyDeposited':
this.balance += event.data.amount
break
case 'MoneyWithdrawn':
this.balance -= event.data.amount
break
}
}
}
Integration Patterns
API Gateway
// Route requests to appropriate services
const routes = {
'/api/users/*': 'http://user-service:3001',
'/api/orders/*': 'http://order-service:3002',
'/api/products/*': 'http://product-service:3003'
}
// Gateway middleware
app.use('/api/*', async (req, res) => {
const service = matchRoute(req.path, routes)
// Authentication
const user = await authenticate(req.headers.authorization)
// Rate limiting
await rateLimiter.check(user.id)
// Proxy request
const response = await proxy(service, {
...req,
headers: {
...req.headers,
'x-user-id': user.id
}
})
res.status(response.status).json(response.data)
})
Circuit Breaker
class CircuitBreaker {
private failures = 0
private lastFailure: Date | null = null
private state: 'closed' | 'open' | 'half-open' = 'closed'
async call<T>(fn: () => Promise<T>): Promise<T> {
if (this.state === 'open') {
if (this.shouldReset()) {
this.state = 'half-open'
} else {
throw new CircuitOpenError()
}
}
try {
const result = await fn()
this.onSuccess()
return result
} catch (error) {
this.onFailure()
throw error
}
}
private onSuccess() {
this.failures = 0
this.state = 'closed'
}
private onFailure() {
this.failures++
this.lastFailure = new Date()
if (this.failures >= this.threshold) {
this.state = 'open'
}
}
private shouldReset(): boolean {
return Date.now() - this.lastFailure!.getTime() > this.timeout
}
}
Saga Pattern
// Distributed transaction coordination
class OrderSaga {
async execute(orderData: CreateOrderDTO) {
const steps = [
{ action: () => this.reserveInventory(orderData), compensate: () => this.releaseInventory(orderData) },
{ action: () => this.processPayment(orderData), compensate: () => this.refundPayment(orderData) },
{ action: () => this.createOrder(orderData), compensate: () => this.cancelOrder(orderData) },
{ action: () => this.sendConfirmation(orderData), compensate: () => {} }
]
const completed: typeof steps = []
try {
for (const step of steps) {
await step.action()
completed.push(step)
}
} catch (error) {
// Compensate in reverse order
for (const step of completed.reverse()) {
await step.compensate()
}
throw error
}
}
}
Scalability Patterns
Horizontal Scaling
# Kubernetes deployment
apiVersion: apps/v1
kind: Deployment
metadata:
name: api-service
spec:
replicas: 3
selector:
matchLabels:
app: api-service
template:
spec:
containers:
- name: api
image: api-service:latest
resources:
requests:
cpu: 100m
memory: 256Mi
limits:
cpu: 500m
memory: 512Mi
---
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
name: api-service-hpa
spec:
scaleTargetRef:
apiVersion: apps/v1
kind: Deployment
name: api-service
minReplicas: 2
maxReplicas: 10
metrics:
- type: Resource
resource:
name: cpu
target:
type: Utilization
averageUtilization: 70
Caching
class CacheService {
constructor(private redis: Redis) {}
async get<T>(key: string): Promise<T | null> {
const cached = await this.redis.get(key)
return cached ? JSON.parse(cached) : null
}
async set<T>(key: string, value: T, ttl?: number): Promise<void> {
const serialized = JSON.stringify(value)
if (ttl) {
await this.redis.setex(key, ttl, serialized)
} else {
await this.redis.set(key, serialized)
}
}
async getOrSet<T>(
key: string,
fn: () => Promise<T>,
ttl?: number
): Promise<T> {
const cached = await this.get<T>(key)
if (cached) return cached
const value = await fn()
await this.set(key, value, ttl)
return value
}
}
// Usage
const user = await cache.getOrSet(
`user:${id}`,
() => userRepository.findById(id),
3600 // 1 hour TTL
)
Integration
Used by:
system-architectagenttech-leadagent