Design an Email Service: The Junior, Senior and Staff Answer
Designing an email service is a classic system-design interview problem. It forces you to think about high-throughput request paths, durability of user data, and the trade-offs between latency and consistency. Below is a step-by-step walk-through of what the interviewer is looking for, the core numbers that drive the design, and how the answer evolves from a junior to a senior to a staff level.
What the Interviewer Is Testing
- Scalability – Can you design a system that handles millions of emails per day?
- Reliability – How do you guarantee delivery and avoid lost messages?
- Data modeling – Do you understand how to store user mailboxes, drafts, and metadata?
- Operational insight – Do you think about monitoring, alerting, and cost?
- Communication – Can you explain each component clearly and justify choices?
Core Requirements and Driving Numbers
| Requirement | Typical Value (hedged) |
|---|---|
| Active users | ~10 million users |
| Emails sent per day | ~100 million (≈1 200 per second) |
| Latency SLA for sending | < 1 second for 99 % of requests |
| Storage per user | Roughly 5 GB of mail (attachments, drafts) |
| Write durability | At least "once" guarantee, preferably "exactly-once" for user-visible actions |
These numbers are enough to drive architecture decisions. A system that must sustain roughly 1 200 send requests per second needs a horizontally scalable front-end, a queue to smooth bursts, and a durable store for both the email content and the user mailbox index.
Core Design – One Hop at a Time
Below is a prose description of the request path, the data model, and the key design choice.
1. Ingress – API Gateway + Load Balancer
The client (web or mobile) hits an Amazon API Gateway endpoint. API Gateway provides request throttling, authentication (via Cognito or JWT), and a thin layer of request validation. Behind it sits an Elastic Load Balancer (ELB) that distributes traffic to a fleet of Amazon EC2 or AWS Fargate containers running the email service.
2. Front-end Service
The front-end validates the sender, checks spam-policy limits, and writes a write-ahead log entry to an Amazon SQS queue. SQS decouples the request from downstream processing, allowing the front-end to respond quickly (< 1 second) while guaranteeing that the message will be retried if downstream services fail.
3. Processing Workers
A pool of AWS Lambda functions or EC2 workers poll the SQS queue. Each worker performs:
- Content sanitization and attachment scanning (via Amazon S3 for temporary storage).
- Persistence of the email metadata to Amazon DynamoDB (partition key = userId, sort key = timestamp).
- Delivery to the recipient’s mailbox (also DynamoDB) and optional push to a Kafka on MSK topic for downstream analytics.
4. Mailbox Store
User mailboxes are stored in DynamoDB because it offers low-latency reads/writes and automatic scaling. The schema is simple:
{
"userId": "string",
"mailId": "uuid",
"timestamp": "ISO8601",
"subject": "string",
"bodyKey": "s3://bucket/key",
"status": "sent|delivered|read"
}Attachments and large bodies live in S3; the DynamoDB item only stores a pointer.
5. Caching Layer
Frequently accessed mailbox indices (e.g., recent 50 messages) are cached in Amazon ElastiCache (Redis). The cache is populated on read-through and invalidated on write. This reduces DynamoDB read-capacity consumption and improves UI latency.
6. Outbound Delivery
For external SMTP delivery, a separate worker pulls from the Kafka topic and talks to third-party mail relays. Successful deliveries update the DynamoDB status; failures trigger a retry loop with exponential back-off.
7. Monitoring & Alerting
All components emit Amazon CloudWatch metrics. Critical alerts include SQS queue depth, Lambda error rates, DynamoDB throttling, and cache miss ratios.
What a Complete Junior Answer Covers
- Lists the basic components: API Gateway, load balancer, SQS, DynamoDB, S3.
- Draws a single request path from client to storage.
- Mentions latency SLA and rough traffic numbers.
- Provides a simple data model for email metadata.
- Explains why durability matters (e.g., "once-and-only-once" guarantee).
What a Senior Answer Adds
- Introduces ElastiCache for read-heavy mailbox queries.
- Shows a queue-based worker model (Lambda or EC2) to smooth spikes.
- Discusses idempotency keys to achieve exactly-once semantics.
- Adds a Kafka on MSK stream for analytics and audit trails.
- Covers basic failure handling: retry policies, dead-letter queues, and partial failures.
- Provides a rough cost estimate (e.g., DynamoDB read/write units vs. expected QPS).
What a Staff Answer Adds
- Failure modes: detailed discussion of data-center outage, network partition, and the loss of a whole region. Shows how multi-AZ DynamoDB replicas and cross-region S3 replication mitigate these.
- Operational readiness: capacity planning, auto-scaling policies for EC2/Fargate, Lambda concurrency limits, and cache eviction strategies.
- Cost optimization: use of DynamoDB on-demand vs. provisioned capacity, S3 lifecycle policies for old attachments, and spot instances for workers.
- Trade-off defense: argues why DynamoDB was chosen over Aurora (lower latency, automatic scaling) despite higher per-GB cost, and why SQS was preferred to a pure Lambda-triggered flow (back-pressure handling).
- Security: encryption at rest (KMS), TLS for API Gateway, IAM least-privilege roles.
- Compliance: retention policies for email archives, GDPR-style deletion via DynamoDB TTL.
Common Mistakes That Sink the Question
| Mistake | Why It Fails |
|---|---|
| Ignoring scale numbers | Leads to under-provisioned components and unrealistic latency claims. |
| Using a monolithic design | No separation of concerns; cannot handle burst traffic or isolate failures. |
| Forgetting durability | Emails are user-visible data; losing them breaks trust. |
| Over-engineering with unnecessary services | Adds complexity without measurable benefit; interviewers look for justified trade-offs. |
| No monitoring plan | Operations team cannot detect or respond to issues; interviewers expect CloudWatch alarms. |
| Skipping idempotency | Duplicate sends appear during retries, a classic bug in email systems. |
Quick Comparison of the Three Levels
| Aspect | Junior Answer | Senior Answer | Staff Answer |
|---|---|---|---|
| Core components | API GW, ELB, SQS, DynamoDB, S3 | Adds ElastiCache, Kafka on MSK, Lambda workers | Adds multi-AZ DynamoDB, cross-region S3 replication, spot workers |
| Failure handling | Basic retry on SQS | Dead-letter queue, idempotency keys | Detailed outage scenarios, graceful degradation plans |
| Operational concerns | Mention CloudWatch metrics | Capacity planning, auto-scaling policies | Cost modeling, security, compliance, SLA budgeting |
| Depth of explanation | High-level flow | Detailed request path, caching strategy | Full trade-off analysis, defense of every major choice |
How to Practice This
- Sketch the request path on a blank canvas. Start with the client, then add API Gateway, load balancer, queue, workers, storage, and cache. Label each hop with its latency target.
- Write a brief rubric: list the junior, senior, and staff expectations. Use it to self-grade a practice attempt.
- Use System Design AI to draw your own answer and get a review of missing components or weak justifications.
Questions people ask
What traffic volume should I assume for an email service interview?
A reasonable ballpark is 100 million emails per day, which translates to about 1 200 send requests per second. This drives the need for horizontal scaling and queue buffering.
Why choose DynamoDB over a relational database like Aurora?
DynamoDB offers single-digit millisecond latency at any scale, automatic sharding, and built-in TTL for email expiration. Aurora provides richer query capabilities but requires manual scaling and can become a bottleneck under bursty write loads.
How do I guarantee exactly-once delivery of an email?
Use an idempotency token generated by the client and stored with the email record. Workers check the token before persisting; if it already exists, they skip duplicate processing. Combine this with SQS's at-least-once delivery guarantee.
What is a common cost-saving technique for storing attachments?
Store large bodies and attachments in S3 with lifecycle rules that transition older objects to cheaper storage classes (e.g., Infrequent Access or Glacier) after a set period.