Backend Design Patterns

![Build Status]()

Production-grade, zero-dependency implementations of core distributed system patterns in TypeScript.

Designed for engineers who need clean, reference implementations without the bloat of heavy frameworks.

Patterns

$3

A ring-based consistent hashing implementation with virtual nodes.
- Complexity: O(log N) lookup.
- Use Case: Sharding data across distributed caches or databases.

$3

High-performance lazy-refill token bucket.
- Features: Burst support, thread-safe logic (for Node.js event loop).
- Use Case: API rate limiting, traffic shaping.

$3

Robust state machine for fault tolerance.
- States: CLOSED -> OPEN -> HALF_OPEN
- Use Case: preventing cascading failures in microservices.

$3

Probabilistic data structure for space-efficient set membership.
- Complexity: O(k) for add/check (k = hash count).
- Use Case: Caches (filtering non-existent keys), Web Crawlers (visited URLs).

$3

Log-Structured Merge Tree basics (MemTable + SSTable).
- Complexity: O(log N) write, O(read_amplification) read.
- Use Case: Write-heavy databases (Cassandra, RocksDB).

System Design Guide

We included a cheat sheet for choosing the right pattern in interviews.

Installation

``bash
npm install backend-design-patterns
`

Try it Live

Want to see these patterns in action? We included a simulated server environment.

`bash
npm run demo
`
Simulates a Load Balancer + Rate Limiter + Circuit Breaker handling traffic.

Usage

$3

`typescript
import { ConsistentHashing } from 'backend-design-patterns/consistent-hashing'

const ch = new ConsistentHashing()
ch.addNode('redis-1')
ch.addNode('redis-2')

const node = ch.getNode('user-session-123')
console.log(Assign to: ${node})
`

$3

`typescript
import { TokenBucket } from 'backend-design-patterns/rate-limiter'

const limiter = new TokenBucket(100, 10) // 100 capacity, 10 tokens/sec
if (limiter.tryConsume(1)) {
// Handle request
} else {
// 429 Too Many Requests
}
// 429 Too Many Requests
}
`

$3

`typescript
import { BloomFilter } from 'backend-design-patterns/bloom-filter'

const filer = new BloomFilter(1024, 3)
filter.add('superuser')

if (filter.mightContain('superuser')) {
// It MIGHT be in the set
}
`

Benchmarks

Core patterns are optimized for high-throughput environments.

| Pattern | Operation | Ops/Sec (approx) |
|---------|-----------|------------------|
| Token Bucket | tryConsume | 25,000,000+ |
| Consistent Hashing | getNode | 3,000,000+ |
| Bloom Filter | mightContain | 15,000,000+ |
| LSM Tree | put (MemTable) | 500,000+ |

Measured on standard i7 equivalent hardware using npm run benchmark.

Development

This project uses TypeScript and Vitest.

`bash
npm install
npm test
``

Contributing

We welcome contributions! Please keep implementations minimal and zero-dependency.
See CONTRIBUTING.md for details.

---

Simple. Robust. TypeScript.