# Third Normal Form (3NF)

> Third normal form (3NF) requires a table to already be in 2NF and to have no transitive dependency, so no non-key column depends on another non-key column. Every non-key column must depend directly on the primary key; a violation is usually fixed by moving the indirectly dependent columns into their own table.

Canonical: https://devsunite.com/resources/core-subjects/dbms/third-normal-form-3nf
Last updated: 2026-11-22

Subject: DBMS · Category: RDBMS Design · 4 min read

Third Normal Form (3NF) builds on Second Normal Form and adds a further requirement: no non-key attribute should depend on another non-key attribute. Every non-key column must depend directly, and only, on the primary key, not transitively through some other column.

## The rule, precisely

A table is in 3NF if it's already in 2NF, and it has no transitive functional dependency: there's no non-key column B such that the key determines B, and B (itself not a key) determines some other non-key column C.

## A worked example, violation and fix

Consider an `employees` table:

| employee_id | employee_name | department_id | department_name |
|--------------|-----------------|----------------|--------------------|
| 1 | Meera | 10 | Engineering |
| 2 | Karan | 10 | Engineering |
| 3 | Divya | 20 | Sales |

This table is in 2NF (its key, `employee_id`, is a single column, so there's no possible partial dependency). But it's not in 3NF. Here's why: `employee_id -> department_id`, and separately, `department_id -> department_name`. That means `employee_id` determines `department_name` only *transitively*, through `department_id` as the middle step, not directly. `department_name` isn't really a fact about an employee at all, it's a fact about a department.

This causes the same kind of redundancy problem 2NF fixes, just through a different mechanism: "Engineering" is stored twice, once per employee in that department, and if the department is ever renamed, every row for every employee in it needs updating.

**Fix: split off the transitively-dependent part.**

`employees`

| employee_id | employee_name | department_id |
|--------------|-----------------|----------------|
| 1 | Meera | 10 |
| 2 | Karan | 10 |
| 3 | Divya | 20 |

`departments`

| department_id | department_name |
|----------------|--------------------|
| 10 | Engineering |
| 20 | Sales |

Now `department_name` lives in exactly one place, `departments`, where it depends directly on `department_id`. `employees` only holds facts that are directly, non-transitively true about an employee: their name and which department they belong to. Renaming a department now means updating exactly one row.

## Distinguishing 2NF from 3NF

2NF is about a value depending on only *part* of a composite key (irrelevant if the key is a single column). 3NF is about a value depending on *another non-key column* instead of the key directly, which can happen even with a single-column primary key, exactly as in the `employees` example above, where `employee_id` is a single-column key but `department_name` still transitively depends on it through `department_id`.

## Where this matters in real systems

3NF is the practical target most production relational schemas aim for. It eliminates the overwhelming majority of real redundancy and anomaly problems while keeping the schema reasonably simple (not fragmented into an excessive number of tiny tables the way pushing to BCNF or beyond sometimes requires). Recognizing a transitive dependency, "this column is really describing something else, not the row's own key", is one of the most valuable instincts a backend engineer or DBA develops with experience.

## What interviewers actually ask about 3NF

- **"What does Third Normal Form require, beyond 2NF?"** No transitive dependency: every non-key column must depend directly on the key, not through another non-key column.
- **"Identify the transitive dependency in this table."** A very common practical question, given a table like the `employees` example, spotting that a column depends on another non-key column rather than the key directly.
- **"What's the difference between 2NF and 3NF?"** 2NF concerns dependency on part of a composite key; 3NF concerns dependency through another non-key column, which can happen even with a single-column key.
- **"Why is 3NF often considered the practical target for real schemas?"** It eliminates most real-world redundancy and anomaly problems without fragmenting the schema as aggressively as BCNF sometimes requires.

## Key takeaways

- 3NF requires 2NF plus no transitive dependency: non-key columns must depend directly on the key, never through another non-key column.
- A transitive dependency means a column is really describing some other entity (like a department), not the row's own primary subject (like an employee).
- The fix is splitting the transitively-dependent column into its own table, keyed on the column it actually depends on.
- 3NF is the common practical normalization target for most real-world production schemas.

## Related

- [Previous: Second Normal Form (2NF)](https://devsunite.com/resources/core-subjects/dbms/second-normal-form-2nf)
- [Next: Boyce-Codd Normal Form (BCNF)](https://devsunite.com/resources/core-subjects/dbms/boyce-codd-normal-form-bcnf)
- [More in RDBMS Design: Features of a Good Relational Database Design](https://devsunite.com/resources/core-subjects/dbms/features-of-good-design)
- [More in RDBMS Design: Functional Dependencies and Their Types](https://devsunite.com/resources/core-subjects/dbms/functional-dependencies-and-types)
- [More in RDBMS Design: Introduction to Decomposition](https://devsunite.com/resources/core-subjects/dbms/introduction-to-decomposition)
- [More in RDBMS Design: Understanding Normalization](https://devsunite.com/resources/core-subjects/dbms/understand-normalisation)
- [More in RDBMS Design: First Normal Form (1NF)](https://devsunite.com/resources/core-subjects/dbms/first-normal-form-1nf)
- [All 174 DBMS interview questions](https://devsunite.com/resources/core-subjects/dbms)
