📋

First Normal Form (1NF)

The entry gate to normalization: one atomic value per cell, no repeating groups. Learn to spot 1NF violations and fix them by expanding rows — the foundation every higher normal form builds on.

Atomic Values No Repeating Groups Row Expansion Composite Keys

Press Next → or use ← → arrow keys

Section 01

The Story — The Comma-Separated Nightmare

📵 REAL-WORLD ANALOGY

The gradebook nobody could search

A teacher crams two phone numbers into one spreadsheet cell: "99887766, 99112233". Now there's no clean way to search for a number, adding a third means editing text, and a single typo corrupts multiple values at once. All of it traces back to breaking one rule: one value per cell.

💡

The Core Idea

A table is in 1NF when every cell holds a single, indivisible value and there are no repeating groups — no lists, arrays, or cloned columns.

Section 02

What Is First Normal Form?

Normalization restructures tables to cut redundancy and prevent anomalies, progressing 1NF → 2NF → 3NF → BCNF. 1NF is the entry gate — every later form depends on it.

Rule	Meaning
Atomic values	Each cell holds one indivisible value — no lists or sets
No repeating groups	No Phone1, Phone2, Phone3 style cloned columns
Single domain per column	Every value in a column shares the same type
Unique column names	No duplicate column identifiers
Order is irrelevant	Row and column sequence carries no meaning
Rows are unique	A primary key identifies each row

🎓

Codd's Baseline (1970)

A relation draws each attribute from an atomic domain; since relations are sets, tuples are unordered and non-duplicate. 1NF is what makes relational algebra and SQL apply cleanly.

Section 06 · Violation 1

Violation — Multivalued Attribute

🔑

The Primary Key Changes

Before: one row per student, PK = Roll. After: Roll 1 spans two rows, so Roll alone loses uniqueness — the key becomes the composite {Roll, Phone}.

Section 07 · Violation 2

Violation — Repeating Groups (Cloned Columns)

🚫

Why Cloned Columns Hurt

They waste space with NULLs, impose an artificial limit (only three courses ever), and make "find every student taking OS" scan three columns. The fix is more rows, not more columns.

Section 06 · The Key

After 1NF — What Becomes the Key?

Row expansion makes the old single-column key lose uniqueness, so the multivalued column joins it to form a composite key.

Table	Before 1NF	After 1NF
STUDENT	PK = Roll	PK = {Roll, Phone}
ENROLL	PK = Roll	PK = {Roll, Course}

🔑

Why It's Composite Now

Roll = 1 spans two rows after expansion, so Roll alone can no longer identify a row. The smallest unique column set is the pair {Roll, Phone} — both become prime attributes; Name stays non-prime.

➡️

This Sets Up 2NF

With key {Roll, Phone}, Name depends on only half the key (Roll → Name) — a partial dependency. Removing it by splitting the table is the next stage, 2NF.

Section 08

How to Convert a Table to 1NF

🔧 THE FOUR-STEP PROCEDURE

1

Identify every column storing a list or set of cloned columns (Course1, Course2…).

2

Make each value atomic — one value per cell.

3

Place the multi-valued data into separate rows of the same table (row expansion).

4

Define a primary key that uniquely identifies every row — often a composite key after expansion.

🧱

1NF Stays ONE Table — Do Not Split Yet

Row expansion duplicates other columns (Raj repeats on each phone row). Removing that redundancy by extracting a separate child table (STUDENT_PHONE keyed by Roll) is the next stage — 2NF, not 1NF. First normal form only needs atomic values in a single table.

Section 09

Why 1NF Matters — Seen Through a Query

Find the student who owns phone 99112233.

Before 1NF — CSV blob

SELECT * FROM STUDENT
WHERE Phone LIKE '%99112233%';

Matches substrings by accident · ignores indexes · slow · fragile.

After 1NF — atomic

SELECT Roll FROM STUDENT
WHERE Phone = '99112233';

Exact match · index-friendly · fast and correct.

Operation	Before 1NF (CSV)	After 1NF (atomic)
Search a value	LIKE scan, error-prone	exact match, indexed
Add a value	edit a text string	INSERT one row
Count values	parse the string	COUNT(*) rows
Enforce uniqueness	impossible	UNIQUE constraint

Sections 03–05

Two Lenses on the Same Rule

🎓

Academic lens

1NF is part of the definition of a relation: values from atomic domains, a set that's unordered and duplicate-free. It's what lets relational algebra and every higher normal form apply.

🏭

Industry lens

1NF makes data queryable, indexable and trustworthy — enabling exact matches, B-tree indexes, foreign keys, CHECK constraints and clean ETL. CSV blobs quietly sabotage all of it.

🧩

"Atomic" Is Contextual

"Raj Sharma" is atomic if you never query the surname — but becomes non-atomic the moment you do. Atomic means "indivisible for this design's purposes." Postgres arrays/JSONB and MongoDB relax 1NF on purpose — a deliberate trade-off, never an accidental CSV field.

Section 10

The 1NF Verification Checklist

✅ TICK ALL FIVE TO CONFIRM 1NF

1

Does every cell hold a single value (no lists, no CSVs)?

2

Are there no cloned columns like X1, X2, X3?

3

Does each column hold a single, consistent type?

4

Are all column names unique?

5

Is there a primary key making every row unique?

🎯

All Five "Yes" → You're in 1NF

The foundation is established. Now you can move on to remove partial dependencies (2NF) and transitive dependencies (3NF).

Section 11

Three Common Mistakes

🧬

"Phone1, Phone2 fixes it"

Cloned columns are also a 1NF violation (a repeating group). The real fix is adding rows, not columns.

⚛️

"Atomic" is absolute

Atomicity depends on context — a full name or date may be atomic or not, depending on whether your app needs the parts.

🔑

Forgetting the primary key

1NF requires uniquely identifiable rows. Atomic values without a key still can't reliably target a specific row.

📸

Row Expansion, Not Column Cloning

The single most important habit: when a cell holds many values, spread them down into more rows — never sideways into more columns.

Section 12

Golden Rules of First Normal Form

🏆 NON-NEGOTIABLE PRINCIPLES

1

One value per cell — no lists, sets, or comma-separated blobs.

2

No repeating groups — never clone columns into X1, X2, X3; add rows instead.

3

One domain per column, unique names, order-independent — the relational fundamentals.

4

Every row needs a primary key — uniquely identifiable rows are part of 1NF (often composite after expansion).

5

Academically it defines the relation; industrially it makes data queryable, indexable and trustworthy.

6

Relax it only on purpose — arrays and JSON are deliberate trade-offs, never accidental CSV fields.

FINAL

The Entry Gate to Normalization

1Value per cell

0Repeating groups

RowsExpand, don't clone

{K,…}Composite key emerges

🎯

The Foundation Is Set

1NF makes every cell atomic and every row uniquely keyed — the baseline that SQL, indexing and all higher normal forms assume. But row expansion left a redundancy behind (Raj repeats on every phone row). Removing that partial dependency is the next step: Second Normal Form (2NF).

🧠

One Sentence to Remember

1NF = one atomic value per cell, no repeating groups — fix violations by expanding rows (and expect a composite key), never by cloning columns.

📋 End of tutorial · Press ← to review, or click Restart