Edge Storage TCO: Cloudflare D1 and KV vs AWS DynamoDB & Aurora

When designing serverless architectures, storage selection directly dictates long-term Total Cost of Ownership (TCO) and read latency. Traditional cloud data stores like AWS DynamoDB, Amazon Aurora Serverless v2, and Google Cloud Spanner require teams to balance provisioning minimum capacity units, baseline storage allocations, VPC peering, and NAT Gateway egress charges.

Cloudflare offers natively distributed edge storage solutions: Workers KV (a low-latency global key-value store) and Cloudflare D1 (a serverless relational SQL database built on SQLite). This article evaluates the TCO and operational advantages of edge storage against conventional cloud architectures.

1. Architectural Fit: KV vs. D1

• Cloudflare Workers KV:
  • Model: Key-Value store with eventual consistency.
  • Optimal For: High-frequency reads (>99% read ratio), session validation tokens, dynamic feature toggles, localized translations.
  • Latency: Direct read access from edge RAM/SSD in 300+ cities (< 5ms).
• Cloudflare D1:
  • Model: Relational SQL (SQLite core) with strong write consistency and distributed edge read replicas.
  • Optimal For: User accounts, order metadata, permission models, structured relational queries with JOIN operations.
  • Latency: Native compiled SQL execution at the edge.

2. Monthly TCO Comparison: AWS Aurora Serverless vs. Cloudflare D1

Consider a mid-scale B2B SaaS application profile:

• Database Size: 10 GB
• Read Operations: 50 Million row reads / month
• Write Operations: 5 Million row writes / month

Architecture A: AWS Aurora Serverless v2 (PostgreSQL)

• Minimum 0.5 ACU baseline standby ($0.06/ACU-hour$\times$730h) = **$21.90**
• Dynamic load scaling (average 1.5 ACUs during business hours) = ~$65.00
• Storage Allocation (10 GB $\times$ $0.10/GB) = **$1.00**
• I/O Request Fees (55M operations $\times$ $0.20/1M) = **$11.00**
• VPC NAT Gateway ($0.045/hour + traffic fees) = **~$35.00**
• Total AWS Monthly Cost: ~$133.90 / month

Architecture B: Cloudflare D1 (Workers Paid Plan)

• Included Monthly Allocation: 25 Billion row reads & 50 Million row writes.
• Storage Fee (10 GB total; 5 GB included free + 5 GB $\times$ $0.75/GB) = **$3.75**
• Operations Fee: Fully covered under included quotas.
• Base Workers Paid Plan: $5.00
• Total Cloudflare Monthly Cost: ~$8.75 / month

FinOps Outcome: 93.4% cost reduction while completely eliminating VPC and NAT Gateway configuration complexity.

3. Querying Relational Edge Data with D1 (TypeScript)

export interface Env {
  DB: D1Database;
}

export interface UserAccount {
  id: string;
  email: string;
  role: string;
  created_at: string;
}

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const url = new URL(request.url);

    if (url.pathname === '/api/users' && request.method === 'GET') {
      const role = url.searchParams.get('role') || 'member';

      // Parameterized queries protect against SQL injection
      const { results } = await env.DB.prepare(
        'SELECT id, email, role, created_at FROM users WHERE role = ? ORDER BY created_at DESC LIMIT 25'
      )
        .bind(role)
        .all<UserAccount>();

      return new Response(JSON.stringify(results), {
        headers: { 'Content-Type': 'application/json' },
      });
    }

    if (url.pathname === '/api/users' && request.method === 'POST') {
      const payload: any = await request.json();

      const result = await env.DB.prepare(
        'INSERT INTO users (id, email, role, created_at) VALUES (?, ?, ?, datetime("now"))'
      )
        .bind(crypto.randomUUID(), payload.email, payload.role)
        .run();

      return new Response(JSON.stringify({ success: result.success }), { status: 201 });
    }

    return new Response('Not Found', { status: 404 });
  },
};

4. Architectural Boundaries and Limitations

1. Database Sizing Boundaries: D1 is designed for modular, micro-database patterns (e.g., database-per-tenant). For monolithic databases exceeding 100 GB in a single instance, centralized PostgreSQL or distributed solutions like Spanner remain necessary.
2. Write Throughput Limits: D1 utilizes a single-primary write architecture, making it ideal for systems with up to 50–100 writes per second per database instance.

5. Strategic Recommendations

1. Adopt Database-Per-Tenant Architecture: Isolate customer data using dedicated D1 databases to maximize security, streamline backups, and keep costs minimal.
2. Eliminate Redis Standby Costs: Offload transient session stores and cache flags to Workers KV to avoid paying for always-on ElastiCache clusters.