Building Scalable Developer Tools: Engineering Lessons from Email Infrastructure

Building Developer Tools That Scale: Lessons from Email Infrastructure

Francisco Perez developed uncorreotemporal.com to provide programmable temporary email infrastructure for automation, CI pipelines, and AI agents. The system operates on an entirely asynchronous stack including FastAPI, SQLAlchemy, and aiosmtpd to manage the complexities of the 40-year-old SMTP protocol. One hard fact is that SMTP response codes communicate solely to sending servers, meaning rejection is often silent and internal to prevent spammers from verifying addresses.

Why This Matters

Infrastructure primitives like email APIs appear simple at the interface level but fail in invisible ways such as message loss, TTL races, and partial writes. Building these tools for developers requires shifting complexity inward—handling raw RFC 2822 bytes and inconsistent headers—to ensure the external API remains predictable and machine-readable under load. Failing to account for these underlying complexities results in non-deterministic errors that can break critical CI job automation and automation scripts.

Key Insights

• Async by default: Every I/O operation, including database queries and Redis pub/sub, uses Python’s asyncio to handle concurrent WebSocket connections and SMTP sessions without thread-per-connection overhead.
• State-based expiration: The system separates enforcement from cleanup by using a background worker to transition ‘is_active’ status every 60 seconds, preventing expensive Python-level row iteration.
• Real-time event propagation: Redis serves as a notification layer rather than a source of truth, facilitating sub-second ‘new_message’ alerts to WebSocket clients while maintaining durability in PostgreSQL.
• RFC 2822 parsing: Python’s stdlib email module with ‘policy.default’ handles malformed multipart messages, while binary payloads are stored as raw bytes to ensure messages are always re-parseable.
• Isolated failure: The delivery pipeline wraps Redis publishing in try/except blocks after DB commits, ensuring that transient cache failures do not cause permanent message loss.

Working Examples

The aiosmtpd handler for local SMTP ingestion with silent rejection logic.

class MailHandler: async def handle_DATA(self, server, session, envelope) -> str: raw: bytes = envelope.content; for rcpt in envelope.rcpt_tos: address = rcpt.lower().strip(); if not address.endswith(f'@{settings.domain}'): continue; await deliver_raw_email(raw, address); return '250 Message accepted'

Efficient batch expiration using a single SQL statement to avoid loading rows into memory.

async def _expire_mailboxes() -> int: now = datetime.now(timezone.utc); async with AsyncSessionLocal() as db: result = await db.execute(update(Mailbox).where(Mailbox.expires_at <= now, Mailbox.is_active == True).values(is_active=False)); await db.commit(); return result.rowcount

Concurrent WebSocket tasks for managing real-time notifications and keepalive pings.

send_task = asyncio.create_task(_send_loop()); ping_task = asyncio.create_task(_ping_loop()); done, pending = await asyncio.wait([send_task, ping_task], return_when=asyncio.FIRST_COMPLETED); for task in pending: task.cancel()

Practical Applications

• CI/CD Automation: Using uncorreotemporal.com to create isolated inboxes for receiving OTP confirmation emails during automated test runs.
• Pitfall: Relying on polling GET /messages, which introduces latency and consumes API quota compared to event-driven WebSockets.
• Pitfall: Conflating data enforcement with storage reclamation, which leads to race conditions where messages are delivered to expired inboxes before the garbage collector runs.

References:

• https://dev.to/francofuji/building-developer-tools-that-scale-lessons-from-email-infrastructure-161b
• https://uncorreotemporal.com