At 100K users, a single PostgreSQL database works fine.

At 10M users? You need read replicas, connection pooling, and sharding.

The Scaling Journey

Stage 1: Single Database (0-100K users)

Setup: AWS RDS db.t3.medium
Cost: $50/month
Performance: 200ms avg query time

Stage 2: Read Replicas (100K-1M users)

Setup: 1 primary (writes) + 2 replicas (reads)
Cost: $200/month
Performance: 50ms avg query time

Stage 3: Connection Pooling (1M-5M users)

Setup: RDS Proxy + read replicas
Cost: $350/month
Performance: 30ms avg query time

Stage 4: Sharding (5M-10M+ users)

Setup: 4 shards (by user_id hash)
Cost: $1,200/month
Performance: 20ms avg query time

Read Replicas

// Write to primary
await db.primary.query('INSERT INTO users ...');

// Read from replica
await db.replica.query('SELECT * FROM users ...');

Result: 80% of queries hit replicas, not primary.

Connection Pooling

Problem: Each Lambda creates 1 DB connection. 1,000 concurrent Lambdas = 1,000 connections = PostgreSQL crashes.

Solution: RDS Proxy reuses connections.

const pool = new Pool({
  host: 'rds-proxy.amazonaws.com',
  max: 100  // Max connections
});

Query Optimization

Slow query (2.4s):

SELECT * FROM orders WHERE user_id = 123;

Fast query (18ms):

CREATE INDEX idx_user_orders ON orders(user_id);
SELECT * FROM orders WHERE user_id = 123;

Indexes matter!

Sharding

Partition data across multiple databases:

function getShardForUser(userId) {
  return userId % 4;  // 4 shards
}

const shard = getShardForUser(userId);
await dbShards[shard].query('SELECT * FROM users ...');

Trade-off: Cross-shard queries are expensive.

Want to scale your database?
Get Expert Help