What Is Database Normalization Visualizer?
Database Normalization Visualizer is a free online tool by TechnSols that checks a table design against the first, second, and third normal forms, called 1NF, 2NF, and 3NF. Type in a table name, list the columns with their types and the primary key, write the functional dependencies one per line, and the tool gives a verdict for each normal form, names every violation, and shows the decomposition steps that split the table into clean new tables.
A table that looks tidy on a whiteboard can still hide repeated facts. When one order row carries the customer name, the customer email, and the product name together, the same customer details are copied onto every order that customer ever places. Change an email in one row and forget the rest, and the database now disagrees with itself. That is the problem normalization solves, and this tool finds it before a single row is ever stored. The Database Normalization page explains the idea in full.
The tool analyses the design you type. It does not connect to a live database, it does not read your real rows, and it does not need a database login of any kind. Everything runs in your browser, and the report downloads as a plain text file you can keep or share with your team. When the design itself needs a picture first, the Database Schema Visualizer draws it, and when you want to try queries, the SQL Query Playground runs them. If your data starts life as a spreadsheet, the CSV to SQLite Converter turns it into a database file first.
How To Use Database Normalization Visualizer?
Checking a table takes three quick steps. There is no software to install and no account to make. Describe the table, write down what depends on what, and read the verdicts.
Step 1: Type Your Table Design
Enter the table name, then list one column per line as a name, a type, and the letters PK after the type for a key column. For example, write order_id INT PK on the first line and customer_name VARCHAR on the next. The columns you mark with PK are the primary key the checks use, so mark every part of a composite key. A column that can hold more than one value, such as a list of phone numbers in a single cell, goes in the optional multi-valued box. If your data is still in a file, the SQLite to CSV Converter exports it first so you can see the columns clearly.
Step 2: Write The Functional Dependencies
Write one functional dependency per line, in the form left side, arrow, right side. For example, write order_id, product_id to quantity when the quantity belongs to one order line, and write customer_id to customer_name, customer_email when the name and email belong to the customer. A dependency is a fact about your data: if you know the left side, you always know the right side. The tool refuses a dependency that names a column that is not in your list. If you are turning JSON records into rows first, the JSON to SQLite Converter builds the table for you.
Step 3: Read The Verdicts And Download The Report
Press Check Normal Forms and read the three verdicts, one for 1NF, one for 2NF, and one for 3NF. Each violation is named in plain words, with the dependency that causes it and the reason it breaks the rule. Below the verdicts, the decomposition shows each new table with its columns and its primary key. Download the text report for a permanent record. When you want to see how the new design behaves under a real query plan, the Explain Plan Viewer reads it next.
Why Normalize A Database Table?
Normalization is the habit of storing each fact in exactly one place. A table that follows the three normal forms has no repeated facts, so no update can leave half the copies behind. The three forms build on each other: a table in 2NF is always in 1NF first, and a table in 3NF is always in 2NF first.
Stop Update Anomalies Before They Start
An update anomaly is what happens when one fact lives in many rows. A customer changes an email address, and the change lands in three rows but not in the other eleven. From that moment the database holds two different email addresses for one person, and no query can tell which one is right. A table in 3NF keeps the email in one row of a Customers table, so one change is the whole change. When the shape of a file needs checking before it becomes a table, the CSV Structure Validator checks it first.
Keep Inserts And Deletes Honest
Repeated facts corrupt inserts and deletes too. If customer details only exist on order rows, a new customer cannot be recorded until that customer places a first order, and deleting the last order of a customer wipes the customer out by accident. These are the insert anomaly and the delete anomaly, and both come from the same cause: two different subjects, the customer and the order, sharing one table.
Make Every Row Mean One Thing
A clean table has one subject and one key that identifies it. Every other column in the row describes that subject and nothing else. When a row tries to describe two subjects at once, the key has to grow to cover both, and the columns start depending on only part of the key. That is the partial dependency that breaks 2NF, and it is the clearest sign that a table is doing two jobs.
What Can You Do With Database Normalization Visualizer?
A normalization check fits any moment when a table is being designed, reviewed, or repaired.
Check A Student Project Or Assignment
Database courses ask for 1NF, 2NF, and 3NF on real tables, and a hand check is easy to get wrong. Type the assignment table into the tool, write the dependencies the question gives you, and compare the tool verdicts with your own working. The sample Orders table is a ready made practice case: it fails 2NF on two partial dependencies and fails 3NF on one transitive dependency, and the decomposition shows the four clean tables that fix it.
Review A Table Before It Goes Live
A table that goes live with a partial dependency will carry that flaw into every row it ever stores, and fixing it later means migrating live data. Running the check at design time costs a minute and finds the flaw while it is still cheap. The verdicts name the exact dependency to fix, and the decomposition gives the new tables to build, so the review ends with a concrete plan.
Repair A Messy Table You Inherited
An inherited table often grew by adding columns whenever someone needed a new fact, and the result is a wide table with repeated customer details, repeated product names, and a key that no longer fits. Type the table as it stands, list the dependencies you can see in the data, and let the tool name the violations. The decomposition is then the migration plan: one new table per subject, each with its own key, ready for the MySQL to PostgreSQL SQL Translator.
Quality And Settings
The tool has no quality slider and no output format to pick, because a normalization verdict is either right or wrong. What you control is the input: the columns, the key, and the dependencies.
- Mark the full primary key. A composite key needs every part marked with PK, or the 2NF check has nothing to test.
- Write every dependency you know. A missing dependency cannot be detected from the column list alone.
- Keep values atomic. A column that holds a list belongs in its own table, not in a single cell.
- Use the sample first. The Orders table shows a failing design and its fix in one click.
- Download the report. It records the verdicts, the violations, and the new tables for the next person.
Two settings in the design change the answer completely: the choice of primary key and the list of dependencies. Change either one and the tool treats the table as a new design, clears the old result, and waits for a fresh check.
How Database Normalization Visualizer Checks Your Table?
The check runs in three passes, one per normal form, and each pass uses only the design you typed. The first pass looks for repeating groups and multi-valued attributes: any column you listed as multi-valued, and any column typed as a list, an array, or a set, fails 1NF by name. The second pass splits every dependency into single attributes on the right side, then asks whether any non-key attribute depends on only part of the primary key. That is the partial dependency test, and it can only fail when the key has more than one column. The third pass asks whether any non-key attribute depends on another non-key attribute. That is the transitive dependency test.
The decomposition follows the violations in order. Each partial dependency gets its own table, keyed by the part of the key it depends on. Each transitive dependency gets its own table, keyed by the non-key column it depends on. What is left, the columns that depend on the whole key, stays in a table under the original name. The classic summary still holds: every non-key attribute must depend on the key, the whole key, and nothing but the key. Microsoft describes the same three forms in its guide to normalization, and the Database Normalization Description page walks through them with examples.
Privacy
Everything you type stays in your browser. Database Normalization Visualizer runs on your own computer, and nothing you do is uploaded to a server, stored, or shared with anyone. Your table names, column names, and dependencies never leave the page.
Because no account is needed, there is no name, email, or history tied to what you do. Closing the tab ends the session, and the browser clears the design from memory. Your work stays yours, and nothing about it is kept, shared, or sold.
Tips
A few habits make Database Normalization Visualizer work smoother, whether this is your first table or your five hundredth.
- Start from the sample Orders table, then edit it into your own table.
- Write the dependencies before you check, not after, so the verdicts test your thinking.
- Read the violation, not just the verdict, because it names the exact dependency to fix.
- Check the split tables again as a new design, to confirm they pass all three forms.
- Keep the report with the schema, so the next person sees why the tables split this way.
When a design passes all three forms, the job is done for most tables. If the design also needs its documentation written up, the Database Documentation Generator writes it from the finished tables.
More Tools For The Same Job
These tools handle the same kinds of jobs: designing tables, moving data between formats, and checking database work.
- SQL Query Playground: runs SQL queries in the browser to try out a design.
- Database Schema Visualizer: draws a database schema so the tables and links are easy to see.
- SQL Explain Plan Viewer: reads a query plan to show how a query will run.
- CSV to SQLite Converter: turns a CSV file into a SQLite database file.
- SQLite to CSV Converter: exports a SQLite database into CSV files.
- JSON to SQL Insert Converter: turns JSON records into SQL insert statements.
- SQLite to JSON Converter: exports a SQLite database into JSON text.
- JSON to SQLite Converter: builds a SQLite database from JSON text.
- MySQL to PostgreSQL SQL Translator: converts SQL between MySQL and PostgreSQL.
- CSV Structure Validator: checks the shape of a CSV file before it becomes a table.
FAQ
Common questions about checking database normalization online, answered plainly.
Is Database Normalization Visualizer By TechnSols Free?
Yes, Database Normalization Visualizer by TechnSols is completely free to use, with no account, no sign-up, and no usage limit. You can check as many table designs as you like, and everything runs in your browser, so nothing is uploaded or stored anywhere.
What Is The Sample Orders Table And What Does It Prove?
The sample is an Orders table with the key order_id and product_id, plus customer details and a product name. It fails 2NF because customer details depend on order_id alone and the product name depends on product_id alone, and it fails 3NF because the customer name and email depend on customer_id. The split gives tables: Orders, Products, Customers, and Orders Items.
What Is A Partial Dependency?
A partial dependency is when a non-key column depends on only part of a composite primary key instead of the whole key. For example, when customer_name depends on order_id alone while the key is order_id plus product_id, the customer name is stored once per order line instead of once per customer.
What Is A Transitive Dependency?
A transitive dependency is when a non-key column depends on another non-key column instead of directly on the key. For example, when customer_email depends on customer_id, and customer_id itself is not a key, the email reaches the key only through a middle step. Moving the name and email into a Customers table keyed by customer_id removes the middle step.
Does The Tool Connect To My Live Database?
No, the tool never connects to a live database and never reads your real rows. It analyses only the table design you type: the columns, the primary key, and the functional dependencies. That keeps your data private, and it means the verdicts are only as complete as the dependencies you write down.
Type the table, write the dependencies, and read the verdicts.