Performance & Architecture

Mailiam is built for speed and scale, delivering sub-100ms form responses globally through modern cloud architecture.

Performance Metrics

Response Times Measured

Operation	Average Response	95th Percentile
Form Submission	< 50ms	< 100ms
Collection Lookup	< 20ms	< 40ms
Email Delivery	< 200ms	< 500ms
API Calls	< 30ms	< 60ms

Throughput Production Tested

• Forms: 10,000+ submissions/second per region
• Collections: 1,000+ concurrent collections
• API Requests: 50,000+ requests/second
• Email Processing: 1,000+ emails/second

Global Architecture

Edge Deployment

Mailiam uses AWS’s global edge infrastructure for optimal performance:

graph TB
    User[User Submits Form] --> CF[CloudFront Edge]
    CF --> API[API Gateway + Lambda]
    API --> DDB[DynamoDB Global]
    API --> SES[Amazon SES]

    CF --> |"< 50ms"| User

    subgraph "Global Regions"
        API --> |Replicated| US[US East/West]
        API --> |Replicated| EU[Europe]
        API --> |Replicated| AP[Asia Pacific]
    end

Response Path Optimization

1. Form Submission → CloudFront Edge (1-5ms)
2. Authentication → Lambda@Edge (5-10ms)
3. Validation → Regional Lambda (10-20ms)
4. Database Write → DynamoDB (10-30ms)
5. Email Queue → SES Async (5ms)
6. Response → User (< 50ms total)

Performance Features

Collection-Based Optimizations

Collections provide several performance benefits:

• Namespace Caching: Collection settings cached at edge
• Batch Operations: Multiple forms deployed together
• Route Optimization: Faster /f/{collection}/{form} resolution
• Connection Reuse: Shared infrastructure per collection

Database Performance

DynamoDB Global Tables:

• Single-digit millisecond latency
• Automatic multi-region replication
• On-demand scaling
• Global secondary indexes for fast lookups

Optimized Access Patterns:

// Fast collection + form lookup
GET /collections/{slug}/forms/{formSlug}
// Response time: ~5ms

// Efficient submission storage
PUT /submissions/{id}
// Write time: ~10ms

Caching Strategy

Multi-Layer Caching:

1. Edge Cache (CloudFront): Static assets, route mappings
2. Lambda Cache: Collection configurations, form settings
3. Database Cache: Hot data in DynamoDB Accelerator (DAX)
4. Application Cache: Frequently accessed form metadata

Cache Invalidation:

• Automatic on configuration changes
• Manual via CLI: mailiam cache clear
• Graceful rollover during deployments

Scalability Patterns

Horizontal Scaling

Auto-Scaling Triggers:

• CPU > 70% for 2 minutes
• Request rate > 1000 RPS
• Error rate > 1%
• Queue depth > 100 messages

Scaling Events:

Normal Load:    2 Lambda instances per region
Medium Load:    10-50 instances (auto-scale)
High Load:      100+ instances (burst capacity)
Peak Events:    1000+ instances (reserved capacity)

Vertical Optimization

Lambda Configuration:

• Memory: 1024MB (optimal price/performance)
• Timeout: 30 seconds (forms), 5 minutes (batch operations)
• Reserved concurrency for critical operations

Database Optimization:

• Read/write capacity on-demand
• Global secondary indexes for query patterns
• Batch operations for bulk updates

Monitoring & Observability

Real-Time Metrics

CloudWatch Dashboards:

• Form submission rates per collection
• Response time percentiles
• Error rates by endpoint
• Email delivery status

Custom Metrics:

// Form performance tracking
PUT /cloudwatch/metrics
{
  "namespace": "Mailiam/Forms",
  "metrics": [
    {"name": "ResponseTime", "value": 45, "unit": "Milliseconds"},
    {"name": "SubmissionRate", "value": 150, "unit": "Count/Second"}
  ]
}

Performance Debugging

CLI Tools:

# Test form performance
mailiam test performance /f/collection/form

# Analyze bottlenecks
mailiam debug trace submission-id

# Regional performance comparison
mailiam test regions --form /f/collection/form

Debug Headers:

X-Mailiam-Region: us-east-1
X-Mailiam-Duration: 45ms
X-Mailiam-Cache: HIT
X-Mailiam-Trace-ID: abc123-def456

Optimization Techniques

Form Design

Fast Forms:

<!-- Minimal fields for fastest processing -->
<form action="https://api.mailiam.dev/f/collection/form" method="POST">
  <input name="email" type="email" required>
  <textarea name="message" required></textarea>
  <button type="submit">Send</button>
</form>

Optimized JavaScript:

// Async submission with timeout
const form = document.querySelector('form');
form.addEventListener('submit', async (e) => {
  e.preventDefault();

  const controller = new AbortController();
  const timeoutId = setTimeout(() => controller.abort(), 5000);

  try {
    const response = await fetch(form.action, {
      method: 'POST',
      body: new FormData(form),
      signal: controller.signal
    });

    if (response.ok) {
      // Handle success quickly
      form.innerHTML = '<p>✅ Message sent!</p>';
    }
  } catch (error) {
    // Graceful degradation
    form.innerHTML = '<p>⚠️ Please try again</p>';
  } finally {
    clearTimeout(timeoutId);
  }
});

Collection Configuration

Performance-Optimized Settings:

collections:
  mycompany:
    settings:
      # Higher rate limits for better UX
      rateLimit: 200

      # Selective spam protection
      spamProtection: true

      # Async email processing
      emailNotifications: true

    forms:
      contact:
        settings:
          # Aggressive caching for high-traffic forms
          cacheTime: 300

          # Batch processing for efficiency
          batchSize: 100

Infrastructure Tuning

Regional Optimization:

# Deploy to optimal regions
mailiam deploy --regions us-east-1,eu-west-1,ap-southeast-1

# Enable performance mode
mailiam config set performance-mode enabled

# Allocate reserved capacity
mailiam capacity reserve --forms 1000 --duration 24h

Benchmarking

Load Testing

Apache Bench Example:

# Test form submission performance
ab -n 1000 -c 10 -p form-data.txt \
   -T 'application/x-www-form-urlencoded' \
   https://api.mailiam.dev/f/test/benchmark

# Results:
# Requests per second: 2500+ RPS
# 95th percentile: < 100ms
# 99th percentile: < 200ms

K6 Load Test:

import http from 'k6/http';
import { check } from 'k6';

export default function () {
  const formData = {
    email: 'test@example.com',
    message: 'Load test message'
  };

  const response = http.post(
    'https://api.mailiam.dev/f/collection/form',
    formData
  );

  check(response, {
    'status is 200': (r) => r.status === 200,
    'response time < 100ms': (r) => r.timings.duration < 100,
  });
}

Performance Testing

CLI Performance Test:

# Comprehensive performance analysis
mailiam test performance --collection mycompany --duration 60s

# Output:
# ✅ Average response time: 47ms
# ✅ 95th percentile: 89ms
# ✅ 99th percentile: 156ms
# ✅ Error rate: 0.1%
# ✅ Throughput: 2,847 RPS

Cost Optimization

Efficient Usage Patterns

Cost-Effective Configuration:

# Optimize for cost while maintaining performance
collections:
  budget-conscious:
    settings:
      # Conservative rate limits
      rateLimit: 50

      # Efficient spam protection
      spamProtection: true

      # Batch email delivery
      emailBatching: true

Usage Monitoring:

# Track usage and costs
mailiam usage report --period last-month
mailiam costs breakdown --by-collection

Scaling Economics

Usage Level	Cost/1000 Forms	Features Included
Starter	Free	Basic collections, 1K/month
Growth	$0.10	Advanced features, 100K/month
Scale	$0.05	Enterprise features, unlimited

Regional Performance

Latency by Region

Region	Form Response	Email Delivery
US East	25ms	150ms
US West	35ms	180ms
EU West	30ms	160ms
Asia Pacific	45ms	220ms

Optimal Deployment

Multi-Region Strategy:

# Deploy to multiple regions for global performance
mailiam deploy --strategy global

# Region-specific configuration
mailiam config set region us-east-1 --primary
mailiam config set region eu-west-1 --secondary
mailiam config set region ap-southeast-1 --failover

Choose regions based on your user base for optimal performance.