Understanding Normalization
Normalization is the systematic process of organizing a relational schema to reduce redundancy and eliminate insertion, update and deletion anomalies. It works through a series of normal forms, 1NF, 2NF, 3NF and BCNF, each building on the previous one and removing a specific kind of problem, mainly by decomposing tables.
Normalization is the systematic process of organizing a relational schema to reduce redundancy and eliminate the insertion, update, and deletion anomalies that come with it. It works through a series of defined stages, called normal forms, each one built on top of the last, each eliminating a specific, precisely defined kind of problem.
The normal forms, at a glance
- First Normal Form (1NF): every cell holds a single, atomic value, no lists or repeating groups crammed into one column.
- Second Normal Form (2NF): 1NF, plus no partial dependency, every non-key attribute must depend on the entire primary key, not just part of it (only relevant when the primary key is composite).
- Third Normal Form (3NF): 2NF, plus no transitive dependency, every non-key attribute must depend directly on the key, not on another non-key attribute.
- Boyce-Codd Normal Form (BCNF): a stricter version of 3NF, for every functional dependency
A -> B, A must be a superkey, closing a narrow edge case 3NF can miss.
Each of these gets its own full treatment elsewhere; this topic is about the overall process and why it matters as a whole.
Why normalize at all
Un-normalized or under-normalized tables cause real, recurring problems: the same fact gets duplicated across many rows (wasting space and risking values drifting out of sync), certain data can't be inserted without unrelated data being present first, and deleting one row can accidentally destroy unrelated information stored alongside it. Normalization is the disciplined process of restructuring a schema specifically to eliminate these problems, one precisely defined step at a time.
The tradeoff: normalization vs. denormalization
Normalization isn't free. A fully normalized schema, split into many small, focused tables, typically requires more JOIN operations to reconstruct a complete picture for a query, since related data now lives in separate tables instead of one wide row. For read-heavy systems where query speed matters more than write-time data integrity, some deliberate denormalization (intentionally reintroducing some redundancy) is a legitimate, common design choice, not a mistake, as long as it's a conscious tradeoff and not an accident.
A worked example, all the way through
Start with a single flat, unnormalized table:
| order_id | customer_name | products |
|---|---|---|
| 1 | Asha | Keyboard, Mouse |
Not in 1NF: the products column holds multiple values in one cell.
Step to 1NF: split into one row per product.
| order_id | customer_name | product |
|---|---|---|
| 1 | Asha | Keyboard |
| 1 | Asha | Mouse |
Now in 1NF, but not 2NF (assuming the key is {order_id, product}): customer_name only really depends on order_id, not on the full composite key, a partial dependency.
Step to 2NF: split customer_name into its own table.
orders: {order_id, customer_name} -> {1, Asha}
order_products: {order_id, product} -> {1, Keyboard}, {1, Mouse}
Now in 2NF. If orders also stored something like customer_city, and customer_city actually depended on a customer_id rather than directly on order_id, that would be a transitive dependency, and fixing it (pulling customer details into their own customers table) would move the design to 3NF.
Each step targets one specific, well-defined problem, and the process stops once a table satisfies the target normal form for a given design (most real-world schemas aim for 3NF as a practical sweet spot).
Where this matters in real systems
Most production relational schemas are normalized to 3NF as a default, it eliminates the vast majority of real anomalies while keeping the number of tables (and therefore the number of joins needed for common queries) manageable. Going further to BCNF or beyond is less common in practice and usually reserved for very specific integrity-critical needs. Read-heavy analytics systems, on the other hand, often deliberately denormalize (sometimes going all the way to one wide flat table) specifically to avoid the join overhead normalization introduces, trading some redundancy for raw query speed.
What interviewers actually ask about normalization
- "What is normalization, and why does it matter?" The process of restructuring a schema through defined stages (normal forms) to eliminate redundancy and the anomalies it causes.
- "Walk me through normalizing this table." A very common practical exercise: given a flawed flat table, identify which normal form it's missing and restructure it step by step.
- "What's the tradeoff of normalizing a schema?" More tables generally means more joins needed to reconstruct a full picture, which can cost query performance, a real reason some systems deliberately denormalize.
- "What normal form do most production schemas target?" 3NF is the common practical target, it eliminates most real anomalies without excessive table fragmentation.
Key takeaways
- Normalization is a step-by-step process (1NF, 2NF, 3NF, BCNF) that restructures a schema to eliminate specific kinds of redundancy and anomalies.
- Each normal form builds on the previous one and targets one specific, well-defined problem.
- Normalization trades some query simplicity (fewer joins) for stronger data integrity; denormalization is the deliberate reverse tradeoff.
- 3NF is the common practical target for most production relational schemas.
More in RDBMS Design
Browse all DBMS topics
Log in to save which topics you've read across every subject.
Frequently asked questions
What is normalization, and why does it matter?
The process of restructuring a schema through defined stages (normal forms) to eliminate redundancy and the anomalies it causes.
Walk me through normalizing this table.
A very common practical exercise: given a flawed flat table, identify which normal form it's missing and restructure it step by step.
What's the tradeoff of normalizing a schema?
More tables generally means more joins needed to reconstruct a full picture, which can cost query performance, a real reason some systems deliberately denormalize.
What normal form do most production schemas target?
3NF is the common practical target, it eliminates most real anomalies without excessive table fragmentation.