Implementing an Asynchronous Email Sending Service

Email sending is a core feature in many applications — user registration, password reset, notifications, reports, marketing campaigns, and more.
However, sending emails synchronously can severely impact application performance, scalability, and user experience.

In this blog, we’ll explore why and how to implement an asynchronous email sending service, with real-world design patterns and a production-ready mindset.

Why Email Sending Must Be Asynchronous

1. Email Sending Is Slow by Nature

SMTP operations involve:

• DNS resolution
• Network latency
• Mail server validation
• Anti-spam checks

This can easily take hundreds of milliseconds or even seconds. Blocking the main request thread for this is a bad idea.

2. Poor User Experience

If a user clicks “Submit” and your API waits until:

• SMTP server responds
• Email is fully sent

The UI feels slow and unreliable.

3. Scalability Issues

Under load:

• Threads get blocked
• Request queues grow
• Application crashes or times out

Async processing prevents this.

4. Reliability & Retry Handling

Email failures are common:

• Invalid email
• Mailbox full
• SMTP server down

Async services allow retry, logging, and failure handling without affecting users.

What Does “Async Email Service” Mean?

It means:

• The application does not send emails directly in the request lifecycle
• Email sending is delegated to a background process
• The request returns immediately
• Emails are sent independently

High-Level Architecture

Client Request
   ↓
Controller / API
   ↓
Queue / Background Task
   ↓
Email Sender Service
   ↓
SMTP / Email Provider

Step 1: Define an Email Model

Keep email data structured and extensible.

public class EmailMessage
{
    public string To { get; set; }
    public string Subject { get; set; }
    public string Body { get; set; }
    public bool IsHtml { get; set; }
}

Step 2: Create an Email Queue

This decouples your app logic from email sending.

using System.Collections.Concurrent;

public static class EmailQueue
{
    private static readonly ConcurrentQueue<EmailMessage> _queue = new();

    public static void Enqueue(EmailMessage message)
    {
        _queue.Enqueue(message);
    }

    public static bool TryDequeue(out EmailMessage message)
    {
        return _queue.TryDequeue(out message);
    }
}

Why ConcurrentQueue?

• Thread-safe
• Lock-free
• Perfect for background workers

Step 3: Enqueue Email Instead of Sending It

In your controller or service:

EmailQueue.Enqueue(new EmailMessage
{
    To = user.Email,
    Subject = "Welcome!",
    Body = "<h1>Thanks for joining us</h1>",
    IsHtml = true
});

// Return immediately
return Ok("Email queued successfully");

• No SMTP call here.
  No blocking.
  Fast response.

Step 4: Background Email Worker

This worker continuously checks the queue and sends emails.

public class EmailBackgroundWorker
{
    private readonly CancellationTokenSource _tokenSource = new();

    public void Start()
    {
        Task.Run(async () =>
        {
            while (!_tokenSource.Token.IsCancellationRequested)
            {
                if (EmailQueue.TryDequeue(out var email))
                {
                    await SendEmailAsync(email);
                }
                else
                {
                    await Task.Delay(500);
                }
            }
        });
    }

    public void Stop()
    {
        _tokenSource.Cancel();
    }
}

Step 5: Implement Async Email Sending

public async Task SendEmailAsync(EmailMessage message)
{
    using var smtp = new SmtpClient("smtp.example.com", 587)
    {
        Credentials = new NetworkCredential("user", "password"),
        EnableSsl = true
    };

    using var mail = new MailMessage
    {
        From = new MailAddress("noreply@example.com"),
        Subject = message.Subject,
        Body = message.Body,
        IsBodyHtml = message.IsHtml
    };

    mail.To.Add(message.To);

    await smtp.SendMailAsync(mail);
}

This uses:

• SendMailAsync
• Non-blocking I/O
• Scalable thread usage

Step 6: Start Worker on Application Startup

In Global.asax or startup logic:

protected void Application_Start()
{
    var emailWorker = new EmailBackgroundWorker();
    emailWorker.Start();
}

Handling Failures Gracefully

In real systems, emails fail. Always handle:

• Invalid email addresses
• SMTP timeouts
• Temporary server errors

Example:

try
{
    await SendEmailAsync(email);
}
catch (Exception ex)
{
    // Log error
    // Store failed email
    // Retry or mark as failed
}

Advanced Improvements (Production-Ready)

1. Database-Based Queue

Instead of memory:

• Store emails in DB
• Allows restart recovery
• Prevents data loss

2. Retry Strategy

• Retry N times
• Exponential backoff
• Dead-letter queue

3. Rate Limiting

• SMTP providers often limit emails/day
• Prevent account blocking

4. Third-Party Providers

Replace SMTP with:

• SendGrid
• Amazon SES
• Mailgun

Still async. Same architecture.

Benefits of Async Email Service

• Faster API responses
• Better user experience
• Improved scalability
• Fault tolerance
• Cleaner architecture