PostgreSQL Performance & Query Optimization · Lesson

When and How to Index

Learn best practices for deciding which columns to index and how to avoid over-indexing.

When and How to Index is a free PostgreSQL Performance & Query Optimization lesson on CoddyKit — lesson 3 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the PostgreSQL Performance & Query Optimization learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Smart Indexing Starts Here

Indexes are powerful tools for speeding up PostgreSQL queries. But they aren't magic, and blindly adding them can actually hurt performance!

In this lesson, we'll learn the art of smart indexing: when to create indexes, what types to use, and how to avoid common pitfalls like over-indexing.

Indexing Your WHERE Clause

The most common reason to create an index is to speed up searches in your WHERE clauses. If you frequently filter data based on a specific column, an index on that column can dramatically reduce query time.

Think of it like an alphabetical index in a book. Instead of scanning every page, you go straight to the relevant section.

CREATE TABLE users (
  id SERIAL PRIMARY KEY,
  email VARCHAR(255) UNIQUE,
  name VARCHAR(255)
);
INSERT INTO users (email, name) VALUES
('alice@example.com', 'Alice'),
('bob@example.com', 'Bob'),
('charlie@example.com', 'Charlie');

-- To make this query fast, index 'email'
-- CREATE INDEX idx_users_email ON users (email);
SELECT * FROM users WHERE email = 'alice@example.com';

Indexes for JOINs and ORDER BY

Indexes don't just help with filtering; they're also crucial for efficient JOIN operations and sorting results with ORDER BY. When joining two tables, an index on the join columns helps PostgreSQL quickly match rows.

Similarly, an index on columns used in ORDER BY can allow PostgreSQL to retrieve sorted data directly, avoiding a costly sort operation.

CREATE TABLE customers (
  id SERIAL PRIMARY KEY,
  name VARCHAR(255)
);
CREATE TABLE orders (
  id SERIAL PRIMARY KEY,
  customer_id INT,
  order_date DATE
);
INSERT INTO customers (name) VALUES ('Alice'), ('Bob');
INSERT INTO orders (customer_id, order_date) VALUES
(1, '2023-01-01'), (2, '2023-01-02'), (1, '2023-01-05');

-- To speed up this query, index customer_id and order_date
-- CREATE INDEX idx_orders_customer_id ON orders (customer_id);
-- CREATE INDEX idx_orders_order_date ON orders (order_date);
SELECT c.name, o.order_date
FROM orders o
JOIN customers c ON o.customer_id = c.id
ORDER BY o.order_date DESC;

Cardinality: More Unique Values, Better

Cardinality refers to the number of unique values in a column. Columns with high cardinality (many unique values, like user_id or email) are generally excellent candidates for indexing.

An index on a low cardinality column (few unique values, like a boolean flag or gender) is often less effective because the database might still have to scan a large portion of the table.

Multi-Column Indexes: Order Matters

Sometimes, your queries filter or sort on multiple columns. A multi-column (or composite) index can cover these cases. The order of columns in a composite index is crucial due to the "left-most prefix" rule.

An index on (A, B, C) can help queries on A, (A, B), or (A, B, C).
It generally won't help queries only on B, C, or (B, C).

CREATE TABLE products (
  id SERIAL PRIMARY KEY,
  category VARCHAR(50),
  price DECIMAL(10, 2),
  color VARCHAR(20)
);
INSERT INTO products (category, price, color) VALUES
('Electronics', 599.99, 'Black'),
('Books', 25.00, 'Red'),
('Electronics', 120.00, 'Silver');

-- Create a multi-column index
CREATE INDEX idx_prod_cat_price ON products (category, price);

-- This query uses the index efficiently
SELECT * FROM products
WHERE category = 'Electronics' AND price > 100;

Partial Indexes: Targeting Subsets

A partial index is an index created on a subset of rows in a table, defined by a WHERE clause. This can make the index smaller, faster to maintain, and more efficient for queries that only target that specific subset of data.

It's perfect for tables where only a small percentage of rows are frequently queried in a specific way (e.g., "active" users, "pending" tasks).

CREATE TABLE tasks (
  id SERIAL PRIMARY KEY,
  status VARCHAR(20),
  due_date DATE
);
INSERT INTO tasks (status, due_date) VALUES
('pending', '2023-12-31'),
('completed', '2023-11-15'),
('pending', '2024-01-31'),
('archived', '2023-10-01');

-- Index only pending tasks, smaller and faster
CREATE INDEX idx_pending_tasks ON tasks (due_date) WHERE status = 'pending';

-- This query uses the partial index
SELECT * FROM tasks WHERE status = 'pending' AND due_date < '2024-01-01';

Expression Indexes: Computed Values

An expression index allows you to create an index on the result of a function or expression, rather than just a raw column value. This is incredibly useful for queries that transform data before comparison.

Common uses include case-insensitive searches (using LOWER() or UPPER()) or indexing parts of a string or date.

CREATE TABLE contacts (
  id SERIAL PRIMARY KEY,
  email VARCHAR(255)
);
INSERT INTO contacts (email) VALUES
('JOHN.DOE@example.com'),
('jane.doe@example.com'),
('peter.smith@example.com');

-- Index for case-insensitive email searches
CREATE INDEX idx_email_lower ON contacts (LOWER(email));

-- This query uses the expression index
SELECT * FROM contacts WHERE LOWER(email) = 'john.doe@example.com';

When NOT to Index: The Pitfalls

Not every column needs an index. Here are some scenarios where indexes might not help, or even hurt performance:

Low Cardinality: Columns with very few unique values (e.g., a boolean is_active flag) often don't benefit much.
Small Tables: For tables with only a few hundred rows, a full table scan is often faster than an index lookup.
Infrequently Queried Columns: If a column is rarely used in WHERE, JOIN, or ORDER BY clauses, an index is probably unnecessary.

Avoiding Over-Indexing

It's tempting to index everything, but over-indexing is a real problem. Each index comes with overhead:

Write Performance: Every INSERT, UPDATE, or DELETE operation must also update all relevant indexes, slowing down writes.
Disk Space: Indexes consume disk space, sometimes significantly.
Query Planner Overhead: Too many indexes can confuse the query planner, making it harder for PostgreSQL to choose the optimal plan.

Aim for a balanced approach: index what's truly needed.

Index Best Practices

Which of the following scenarios are generally good candidates for creating an index in PostgreSQL?

Recap: Indexing Wisely

You've learned that indexing isn't about indexing everything, but about making strategic choices. Indexes are vital for speeding up WHERE, JOIN, and ORDER BY clauses, especially on columns with high cardinality.

Remember to consider partial and expression indexes for specific needs, and always be mindful of the costs of over-indexing. The goal is to optimize reads without unduly sacrificing write performance or consuming excessive resources.

Frequently asked questions

Is the “When and How to Index” lesson free?

Yes — the full text of “When and How to Index” is free to read here on the web, and the PostgreSQL Performance & Query Optimization course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the PostgreSQL Performance & Query Optimization course, upgrade to CoddyKit PRO.

What will I learn in “When and How to Index”?

Learn best practices for deciding which columns to index and how to avoid over-indexing. You practise PostgreSQL Performance & Query Optimization with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start PostgreSQL Performance & Query Optimization?

No prior experience is required. PostgreSQL Performance & Query Optimization on CoddyKit is structured for beginners through advanced learners; this is — lesson 3 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “When and How to Index” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this PostgreSQL Performance & Query Optimization lesson?

Yes. Every PostgreSQL Performance & Query Optimization lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

← Back to PostgreSQL Performance & Query Optimization