Volver a todas las guías
Diseño de bases de datos··5 min de lectura

Cómo diseñar un esquema de base de datos desde cero: paso a paso

Diseñe un esquema de base de datos relacional desde cero. Un recorrido paso a paso desde los requisitos hasta las tablas, relaciones y restricciones con SQL.

Los requisitos se convierten en entidades, relaciones y un esquema SQL con claves de cliente y pedido
En esta guía
  1. ¿Por qué es importante el diseño del esquema?
  2. Paso 1 — Recopilar requisitos
  3. Paso 2 — Identificar entidades
  4. Paso 3 — Definir atributos y tipos de datos
  5. Paso 4 — Establecer relaciones
  6. Paso 5 — Aplicar restricciones e índices
  7. Paso 6 — Normalizar (luego desnormalizar donde sea necesario)
  8. Referencias y lecturas adicionales

Los ejemplos de SQL utilizan PostgreSQL a menos que se mencione otro dialecto. Los fragmentos cortos asumen que las tablas a las que se hace referencia ya existen. Valide el DDL en su base de datos de destino antes de aplicarlo.

¿Por qué es importante el diseño del esquema?

Un esquema de base de datos bien diseñado es la base de toda aplicación confiable. Hágalo bien y las Consultas serán rápidas, los Datos se mantendrán consistentes y las funciones futuras encajarán sin migraciones dolorosas. Hágalo mal y luchará contra anomalías de Datos, un rendimiento lento y un sinfín de soluciones alternativas durante la vida del proyecto.

Esta guía recorre un proceso de seis pasos para diseñar un esquema desde cero — y termina con un ejemplo completo del mundo real que puedes adaptar para tus propios proyectos.

Paso 1 — Recopilar requisitos

Antes de abrir cualquier herramienta, hable con los interesados. Entienda qué es lo que la aplicación hace, qué Datos gestiona y cómo se relacionan esos Datos. Haga preguntas como:

  • ¿Cuáles son las "cosas" principales que rastrea el sistema? (Usuarios, pedidos, productos...)
  • ¿Qué datos deben ser únicos? (Correos electrónicos, SKU, slugs...)
  • ¿Qué consultas ejecutará la aplicación con mayor frecuencia?
  • ¿Existen restricciones regulatorias? (GDPR, HIPAA …)
  • ¿Cuál es el volumen de datos esperado durante los próximos 1 a 3 años?

Escriba las respuestas: se convertirán en su especificación y guiarán cada decisión posterior.

Paso 2 — Identificar entidades

Un entidad es cualquier cosa de la que el sistema necesite almacenar datos. Cada entidad típicamente se asigna a una tabla de base de datos. Para una plataforma de blog, la lista inicial de entidades podría verse así:

  • Usuario — autores y lectores
  • Publicación — artículos publicados en el blog
  • Categoría — agrupaciones para publicaciones (p. ej., "React", "SQL")
  • Comentario — respuestas de los lectores a las publicaciones
  • Etiqueta — etiquetas de grano fino (muchos a muchos con publicaciones)

Dibuja esto como cajas en una pizarra o usa el Constructor ERD para discutir el modelo conceptual antes de elegir los tipos de columna.

Paso 3 — Definir atributos y tipos de datos

Para cada entidad, enumere los atributos que necesita y elija el tipo de datos SQL más apropiado. Sea lo más específico posible: prefiera VARCHAR(255) sobre TEXT cuando conoces la longitud máxima y prefieres TIMESTAMPTZ sobre TIMESTAMP cuando las zonas horarias importan.

-- Users
id          SERIAL PRIMARY KEY
username    VARCHAR(50)  NOT NULL UNIQUE
email       VARCHAR(255) NOT NULL UNIQUE
password_hash TEXT      NOT NULL          -- store a password hash, never plaintext
bio         TEXT
avatar_url  VARCHAR(500)
created_at  TIMESTAMPTZ  DEFAULT now()

-- Posts
id          SERIAL PRIMARY KEY
author_id   INT          NOT NULL          -- FK → users.id
category_id INT                            -- FK → categories.id
title       VARCHAR(200) NOT NULL
slug        VARCHAR(220) NOT NULL UNIQUE
body        TEXT         NOT NULL
status      VARCHAR(20)  DEFAULT 'draft'   -- draft | published | archived
published_at TIMESTAMPTZ
created_at  TIMESTAMPTZ  DEFAULT now()
updated_at  TIMESTAMPTZ  DEFAULT now()

Paso 4 — Establecer relaciones

Determine cómo se relacionan las entidades entre sí. Los tres tipos fundamentales son:

  • Uno a muchos (1:N) — Un usuario tiene muchas publicaciones; una publicación pertenece a un usuario.
  • Muchos a muchos (M:N) — Una publicación puede tener muchas etiquetas; una etiqueta puede pertenecer a muchas publicaciones. Esto requiere una tabla de unión.
  • Uno a uno (1:1) — Un usuario tiene un perfil. A menudo se fusionan en una sola tabla a menos que los datos del perfil sean grandes o se accedan raramente.
-- Junction table for the posts ↔ tags many-to-many relationship
CREATE TABLE post_tags (
    post_id INT NOT NULL REFERENCES posts (id) ON DELETE CASCADE,
    tag_id  INT NOT NULL REFERENCES tags  (id) ON DELETE CASCADE,
    PRIMARY KEY (post_id, tag_id)
);

Paso 5 — Aplicar restricciones e índices

Las restricciones protegen la calidad de los Datos. Como mínimo, debería considerar:

  • NOT NULL en cada columna que deba tener un valor.
  • UNIQUE en identificadores naturales (correos electrónicos, slugs, nombres de usuario).
  • CHECK restricciones para reglas de dominio (p. ej., el estado debe ser uno de tres valores).
  • DEFAULT valores para marcas de tiempo y columnas de estado.
  • Claves foráneas con especificación explícita ON DELETE acciones.

Luego agregue índices en columnas sobre las que filtrarás, ordenarás o unirás frecuentemente. Las columnas de clave foránea son candidatas principales.

-- Index foreign-key columns for faster joins
CREATE INDEX idx_posts_author   ON posts (author_id);
CREATE INDEX idx_posts_category ON posts (category_id);
CREATE INDEX idx_comments_post  ON comments (post_id);

-- Partial index: only published posts (PostgreSQL)
CREATE INDEX idx_posts_published
    ON posts (published_at DESC)
    WHERE status = 'published';

Paso 6 — Normalizar (luego desnormalizar donde sea necesario)

Normalización elimina datos redundantes organizando columnas y tablas de acuerdo con un conjunto de "formas normales". La mayoría de los esquemas deberían alcanzar Tercera Forma Normal (3NF):

  • 1NF — cada columna contiene valores atómicos; sin grupos repetidos.
  • 2NF — ningún atributo no principal depende solo de una parte de una clave candidata.
  • 3NF — cada dependencia no trivial tiene un determinante superclave o un atributo dependiente que pertenece a una clave candidata.

Después de normalizar, puedes selectivamente desnormalizar para rendimiento — por ejemplo, almacenar un comment_count en el posts tabla para evitar una costosa COUNT(*) en cada carga de página. Desnormaliza deliberadamente y documéntalo.

Esquema completo de plataforma de blog

-- Full SQL for the blog platform schema

CREATE TABLE users (
    id          SERIAL       PRIMARY KEY,
    username    VARCHAR(50)  NOT NULL UNIQUE,
    email       VARCHAR(255) NOT NULL UNIQUE,
    password_hash TEXT      NOT NULL,
    bio         TEXT,
    avatar_url  VARCHAR(500),
    created_at  TIMESTAMPTZ  DEFAULT now()
);

CREATE TABLE categories (
    id   SERIAL       PRIMARY KEY,
    name VARCHAR(100) NOT NULL UNIQUE,
    slug VARCHAR(110) NOT NULL UNIQUE
);

CREATE TABLE posts (
    id           SERIAL       PRIMARY KEY,
    author_id    INT          NOT NULL REFERENCES users (id),
    category_id  INT          REFERENCES categories (id) ON DELETE SET NULL,
    title        VARCHAR(200) NOT NULL,
    slug         VARCHAR(220) NOT NULL UNIQUE,
    body         TEXT         NOT NULL,
    status       VARCHAR(20)  NOT NULL DEFAULT 'draft'
                     CHECK (status IN ('draft','published','archived')),
    published_at TIMESTAMPTZ,
    created_at   TIMESTAMPTZ  DEFAULT now(),
    updated_at   TIMESTAMPTZ  DEFAULT now()
);

CREATE TABLE tags (
    id   SERIAL       PRIMARY KEY,
    name VARCHAR(60)  NOT NULL UNIQUE
);

CREATE TABLE post_tags (
    post_id INT NOT NULL REFERENCES posts (id) ON DELETE CASCADE,
    tag_id  INT NOT NULL REFERENCES tags  (id) ON DELETE CASCADE,
    PRIMARY KEY (post_id, tag_id)
);

CREATE TABLE comments (
    id         SERIAL      PRIMARY KEY,
    post_id    INT         NOT NULL REFERENCES posts (id) ON DELETE CASCADE,
    user_id    INT         NOT NULL REFERENCES users (id),
    body       TEXT        NOT NULL,
    created_at TIMESTAMPTZ DEFAULT now()
);

-- Indexes
CREATE INDEX idx_posts_author    ON posts    (author_id);
CREATE INDEX idx_posts_category  ON posts    (category_id);
CREATE INDEX idx_comments_post   ON comments (post_id);
CREATE INDEX idx_comments_user   ON comments (user_id);

Pegue el esquema completo en el Editor de SQL a ERD para inspeccionar sus relaciones. Use el Constructor ERD para un dibujo conceptual y una conversión SQL revisada.

Referencias y lecturas adicionales

Más publicaciones