sneeakydev

System Design Playground

A selection of backend architectures I’ve designed and operated, highlighting patterns, tradeoffs, and pragmatic decisions.

Payment Processing Engine

Microservices + Event‑Driven

Process payments across multiple providers with idempotency, retries, and settlement workflows.

Components
  • API Gateway and Auth
  • Payment Orchestrator with idempotency keys
  • Provider adapters (Zenith, Ramp, Monnify)
  • Queue for async retries and webhooks
  • Settlement and reconciliation service
Tradeoffs
  • Provider adapters isolate failure domains
  • Event replay simplifies recovery but requires audit discipline
  • Idempotency reduces duplicates, needs careful keying
  • Consistency over availability during reconciliation windows
ClientAPI GatewayOrchestratorProvider AdaptersQueue/WebhooksSettlement/Reconcile

Wallet & Ledger System

Layered + CQRS

Maintain accurate balances with double‑entry ledger and atomic transfers across wallets.

Components
  • Command API for ledger writes
  • Query API for balances and statements
  • Ledger store with double‑entry
  • Transfer service with transactional guarantees
Tradeoffs
  • CQRS improves read scalability, increases model complexity
  • Strict invariants prevent drift but need schema discipline
  • Read replicas accelerate queries with eventual consistency
Command APIQuery APIWrite ModelRead ModelLedger Store

Notification Service

Event‑Driven + Worker Pools

Deliver email, SMS, and webhooks reliably with templating, rate limits, and retries.

Components
  • Producer API enqueues messages
  • Worker pools per channel
  • Rate limiter and backoff
  • Template renderer and provider adapters
Tradeoffs
  • Channel isolation avoids blast radius
  • Queues increase delivery latency but improve resilience
  • Webhook signature verification adds integrity
Producer APIQueueEmail WorkersSMS WorkersWebhook Workers

Transaction Monitoring / Rule Engine

Stream Processing + Rule Evaluation

Detect anomalies and trigger actions using deterministic rules and streaming metrics.

Components
  • Event stream from transactions
  • Rule store and evaluator
  • Action dispatcher (alerts, holds)
  • Feedback loop for tuning
Tradeoffs
  • Deterministic rules are auditable but require curation
  • Streaming evaluation reduces latency, adds operational complexity
  • Batch and stream hybrid for cost control
Txn StreamRule EvaluatorActionsRule Store

Scalable File Upload Service

Layered + Async Processing

Accept large file uploads, validate, store in object storage, and deliver via CDN.

Components
  • Upload API with chunking and presigned URLs
  • Validator and metadata extractor
  • Object storage with lifecycle policies
  • CDN and cache invalidation
Tradeoffs
  • Chunking improves reliability at the cost of complexity
  • Presigned URLs reduce load on API but require careful expiry
  • Lifecycle rules optimize cost for infrequently accessed files
ClientUpload APIObject StorageCDNValidator