Engineering Note
Architecture

Database Schema Design

Performance Lessons from Production

14 min read
AdvancedArchitecture

Introduction

Database schema design is often treated as a one-time setup task. In reality, it is one of the most important decisions for system performance and scalability.

A well-designed schema makes queries fast and predictable. A poorly designed one forces the database to do unnecessary work on every request.

The Problem

Many schemas are designed based on how data looks, not how it will be queried.

  • Missing indexes on frequently queried fields
  • Large joins in performance-critical paths
  • Redundant or inconsistent data structures
  • No clear relationship between tables

The schema works initially but becomes inefficient as data grows.

System Design / Approach

Schema design should start with understanding how the application reads and writes data.

  • Design tables based on access patterns
  • Use indexes to support filtering and sorting
  • Balance normalization with performance needs
  • Keep hot queries simple and efficient

The goal is to make common operations fast and predictable.

Implementation

Step 1: Define Tables Clearly


CREATE TABLE users (
  id SERIAL PRIMARY KEY,
  email TEXT UNIQUE,
  created_at TIMESTAMP
);

Clear structure improves consistency and integrity.

Step 2: Add Indexes


CREATE INDEX idx_users_email ON users(email);

Indexes speed up frequent queries.

Step 3: Optimize Relationships


CREATE TABLE posts (
  id SERIAL PRIMARY KEY,
  user_id INT REFERENCES users(id)
);

Proper relationships maintain data integrity.

Step 4: Avoid Over-fetching


SELECT id, email FROM users;

Fetching only required fields improves performance.

Trade-offs

Approach Benefit Cost
Normalization Data consistency More joins
Denormalization Faster reads Data duplication
Indexing Better performance Extra storage

Real-World Impact

  • Faster query performance
  • Improved scalability
  • Reduced database load
  • More predictable system behavior

Key Takeaways

Schema design should be driven by query patterns, not just data structure

Poor schema decisions become expensive to change at scale

Indexes are as important as tables in performance design

Over-normalization and under-normalization both create problems

Consistency, constraints, and clarity are critical for long-term maintainability

Future Improvements

Introduce composite indexes based on real query patterns

Use partial indexes for filtered datasets

Refactor schema to separate hot and cold data

Add constraints to enforce data integrity

Continuously analyze and optimize slow queries

Database Schema Design | Tushar Kanti Dey