# First Normal Form (1NF)

> First normal form (1NF) is the most basic requirement for a relational table: every cell must hold a single, atomic value, with no lists, sets or repeating groups packed into one column. A 1NF table also keeps one consistent type per column, has unique rows identifiable by a primary key, and avoids repeating columns such as phone1, phone2 and phone3.

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

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

First Normal Form (1NF) is the most basic requirement a relational table must satisfy: every cell must hold a single, atomic (indivisible) value. No cell should contain a list, a set, or any kind of repeating group of values crammed together.

## The rule, precisely

A table is in 1NF if:
1. Every column holds only atomic values, one value per cell, never a list or combination of values.
2. Every column holds values of a single, consistent type.
3. Each row is unique, identifiable by a primary key.
4. There's no repeating group of columns (like `phone1`, `phone2`, `phone3` all meaning the same thing).

## A worked example, violation and fix

Here's a table that violates 1NF:

| student_id | name | subjects |
|------------|------|----------|
| 1 | Asha | Math, Physics, Chemistry |
| 2 | Ravi | Biology |

The `subjects` column packs multiple values into a single cell for Asha's row. This causes real, practical problems: you can't easily query "which students take Physics" without parsing text inside a cell, you can't enforce that each subject is a valid value, and adding or removing one subject means editing a fragile comma-separated string instead of a clean row.

**Fix: split into one row per value.**

| student_id | name | subject |
|------------|------|---------|
| 1 | Asha | Math |
| 1 | Asha | Physics |
| 1 | Asha | Chemistry |
| 2 | Ravi | Biology |

Now every cell holds exactly one atomic value. A query like `SELECT student_id FROM enrollments WHERE subject = 'Physics'` works directly and efficiently, something that was genuinely painful with the comma-separated version.

## The repeating-group version of the same problem

1NF violations don't always look like a comma-separated list; sometimes they show up as repeated columns meaning the same thing:

| student_id | name | subject1 | subject2 | subject3 |
|------------|------|----------|----------|----------|
| 1 | Asha | Math | Physics | Chemistry |

This is also a 1NF violation, `subject1`, `subject2`, `subject3` are a repeating group representing the same underlying fact (a subject a student takes). It has the same practical problems as the comma-separated version: a student taking a fourth subject has nowhere to go without altering the table structure, and querying "who takes Physics" means checking three separate columns instead of one.

The fix is the same: pull `subject` out into its own row per value, exactly as shown above.

## Where this matters in real systems

Violating 1NF is one of the most common real beginner mistakes in schema design, usually from trying to avoid "too many rows" by cramming related values into fewer, wider rows. In practice this backfires immediately: querying, filtering, indexing, and enforcing constraints on packed-together values is all significantly harder than working with one clean value per cell. Nearly every subsequent normal form (2NF, 3NF, BCNF) assumes 1NF already holds, it's the non-negotiable foundation everything else builds on.

## What interviewers actually ask about 1NF

- **"What does First Normal Form require?"** Every cell holds a single atomic value, no lists or repeating groups packed into one column or spread across repeated similarly-named columns.
- **"Is a table with a `phone1`, `phone2`, `phone3` column set in 1NF?"** No, that's a repeating group, a 1NF violation just like a comma-separated list in one cell would be.
- **"How do you fix a 1NF violation?"** Move the repeated/list values into their own rows (or a separate related table), so each cell in the original table holds exactly one value.
- **"Why does 1NF matter for querying?"** Because atomic values can be filtered, indexed, and constrained directly; values packed into one cell or spread across repeated columns require fragile, harder-to-maintain workarounds.

## Key takeaways

- 1NF requires every cell to hold a single atomic value, with no lists or repeating groups.
- A comma-separated list inside one cell, and a set of repeated columns like `subject1`/`subject2`/`subject3`, are both real 1NF violations.
- The fix is to move repeated values into their own row (or separate table), one value per cell.
- 1NF is the foundational requirement every higher normal form (2NF, 3NF, BCNF) assumes already holds.

## Related

- [Previous: Understanding Normalization](https://devsunite.com/resources/core-subjects/dbms/understand-normalisation)
- [Next: Second Normal Form (2NF)](https://devsunite.com/resources/core-subjects/dbms/second-normal-form-2nf)
- [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: Third Normal Form (3NF)](https://devsunite.com/resources/core-subjects/dbms/third-normal-form-3nf)
- [More in RDBMS Design: Boyce-Codd Normal Form (BCNF)](https://devsunite.com/resources/core-subjects/dbms/boyce-codd-normal-form-bcnf)
- [All 174 DBMS interview questions](https://devsunite.com/resources/core-subjects/dbms)
