System Design Project Ideas

Build a fully functional URL shortening service like bit.ly with redirect tracking and basic analytics.

• Generate unique short codes and store long-to-short URL mappings in a database
• Redirect users from short URL to original URL with correct HTTP status codes
• Track click counts and last-accessed timestamps per URL
• Expose a REST API for creating, reading, and deleting short URLs
• Add expiration support so URLs can auto-expire after a set time

Implement a configurable rate limiter that can be plugged into any HTTP service to throttle requests per user or IP.

• Support token bucket and sliding window counter algorithms
• Enforce per-user and per-IP rate limits configurable via a config file
• Return proper 429 status with Retry-After headers when limits are exceeded
• Store rate limit counters in Redis with TTL-based expiry
• Write benchmark tests comparing both algorithms under load

Build an in-memory key-value store backed by a Write-Ahead Log for crash recovery, mimicking the core of Redis or etcd.

• Support GET, SET, DELETE, and TTL commands via a TCP or HTTP interface
• Persist every write operation to a WAL file before acknowledging the client
• Replay the WAL on startup to restore state after a crash
• Support snapshotting to compact the log and speed up recovery
• Measure and report read/write latency in a simple stats endpoint

Design and build a job queue system similar to Celery or Sidekiq where producers enqueue tasks and multiple workers process them concurrently.

• Producers push tasks with priority levels via a REST API
• Multiple worker processes pull and execute tasks concurrently using a broker (Redis or RabbitMQ)
• Implement at-least-once delivery with retry logic and exponential backoff
• Track job status (pending, running, failed, completed) queryable via API
• Add a dead-letter queue for jobs that exceed max retry attempts
• Expose a dashboard endpoint showing queue depth and worker health

Build a multi-channel notification service that fans out messages to email, SMS, and push channels with delivery guarantees.

• Accept notification requests via REST API specifying channel, recipient, and payload
• Fan out each notification to relevant channel workers using a pub/sub model
• Implement idempotency keys to prevent duplicate delivery on retries
• Store delivery receipts and expose a status-check endpoint per notification ID
• Support user preference settings to opt in/out of specific channels
• Rate-limit outgoing messages per channel to respect third-party API quotas

Implement a load balancer using consistent hashing to distribute requests across backend nodes with minimal redistribution when nodes join or leave.

• Implement a consistent hash ring with virtual nodes to balance load evenly
• Route incoming HTTP requests to the correct backend based on hashed request key
• Detect backend node failures via health checks and remove them from the ring
• Add new nodes dynamically and verify minimal key redistribution occurs
• Log which node served each request and visualize load distribution in a report
• Support weighted nodes where higher-capacity servers receive proportionally more traffic

Build a high-throughput leaderboard service capable of handling millions of score updates and serving ranked queries in real time.

• Ingest score update events via a high-throughput API (batch support required)
• Use Redis Sorted Sets to maintain real-time global and per-game leaderboards
• Support top-N queries and rank lookups for any user ID in under 10ms
• Persist leaderboard snapshots to a relational DB every 60 seconds for durability
• Invalidate and refresh caches automatically when scores change significantly
• Expose a WebSocket endpoint that pushes live rank changes to connected clients

Build a distributed full-text search engine with an inverted index, sharded across multiple nodes, inspired by Elasticsearch.

• Parse and index documents into an inverted index stored across multiple shards
• Implement a query coordinator that fans out queries to all shards and merges ranked results
• Support TF-IDF relevance scoring and return results sorted by score
• Replicate each shard to one replica node and serve reads from replicas
• Handle shard node failure by promoting a replica and re-routing traffic automatically
• Provide an admin API to add/remove shard nodes and rebalance the index

Architect and build a microservices-based e-commerce backend using event sourcing and CQRS to handle orders, inventory, and payments reliably.

• Decompose the system into Order, Inventory, and Payment microservices communicating solely via domain events on a message broker
• Implement event sourcing so all state changes are stored as an immutable event log
• Apply CQRS to maintain separate read models (materialized views) for fast query performance
• Implement the Saga pattern to handle distributed transactions such as order-place-then-reserve-inventory-then-charge
• Design idempotent event consumers so replaying events does not cause duplicate side effects
• Add distributed tracing (e.g. OpenTelemetry) to visualize end-to-end request flows across services