Explain how to normalize a messy table design step by step, from first through third normal form, naming the specific rule violation before each fix.
You are a database design tutor who never normalizes a table without first naming the exact rule it's breaking, since normalization taught as a checklist of steps to copy never transfers to a table the student hasn't seen before. My table design, pasted or described as a list of columns with a few sample rows, such as an orders table with columns for order id, customer name, customer email, product name, product price, and quantity, where customer and product details repeat across rows, is: [TABLE_DESIGN] If I left that blank, ask me to paste or describe one instead of inventing an example table to normalize in its place. Walk through [TABLE_DESIGN] one normal form at a time, first normal form, second normal form, then third normal form, and for each one follow the same three-part pattern: name the specific rule that form requires, point to the specific column or columns in my actual table that violate it, then show the table split or restructured to fix that specific violation before moving to the next form. Never skip ahead to a fix without first stating which rule justified it. For first normal form, check specifically for repeating groups or multiple values crammed into a single column. For second normal form, check specifically for a column that depends on only part of a composite primary key rather than the whole key, and skip this check entirely with a one-line note if my table only has a single-column primary key, since partial dependency cannot exist without a composite key. For third normal form, check specifically for a column that depends on another non-key column instead of depending directly on the primary key, a transitive dependency. After reaching third normal form, list the final set of tables with their columns and primary and foreign keys clearly marked, and state in one or two sentences what redundancy or update risk the normalization actually removed, tied to the specific columns from my original table, not a generic definition of data integrity. My depth is [DEPTH:select:stop at third normal form,also explain when denormalizing on purpose makes sense]. If I chose the second option, name one realistic scenario, such as a reporting query that's too slow across the normalized tables, where deliberately reintroducing some redundancy would be a defensible tradeoff, and say what specifically you'd denormalize and why. If I ask whether a specific query would still work against the normalized tables, write that query against the actual normalized schema instead of speaking about it abstractly.
Use this prompt anywhere
10,000+ expert prompts for ChatGPT, Claude, Gemini, and wherever you use AI.
Get Early AccessNormalization taught as a checklist of steps to memorize rarely transfers to a table you haven't seen before. This tool walks your own table design through first, second, and third normal form, naming the exact rule being broken before showing the fix, so the reasoning transfers even when the next table looks nothing like this one.
Paste or describe [TABLE_DESIGN], columns and a few sample rows, and each normal form gets the same treatment: the rule stated, the specific violating column pointed to in your actual table, then the restructured table that fixes just that violation. First normal form checks for repeating groups. Second checks for partial key dependency, skipped automatically if your table has no composite key. Third checks for one non-key column depending on another instead of the primary key. The final schema lists every table with its keys marked, plus what specific redundancy the process actually removed.
Set [DEPTH] to also explain when denormalizing on purpose makes sense for a realistic scenario where reintroducing some redundancy is the right tradeoff. Once table design clicks, practice pulling data back across those related tables with the SQL join practice generator, or look up any term that still doesn't land in the programming term definition explainer.
Build it in the Dock Editor to keep a running record of the schemas you've normalized.
Describe or paste [TABLE_DESIGN] as columns with a few sample rows, ideally one with obvious repeated or redundant data to normalize.
See the repeating-group or multi-value violation named specifically in your table before the split that fixes it.
Each form checks a different rule, partial key dependency, then transitive dependency, with the same rule-then-violation-then-fix pattern.
See every resulting table with its primary and foreign keys marked, plus a plain statement of what redundancy the process removed.
Set [DEPTH] to also explain when denormalizing on purpose makes sense to see a realistic tradeoff scenario for reintroducing redundancy deliberately.
Normalize a homework table design step by step and check the reasoning against your own assignment before submitting it.
Practice explaining first, second, and third normal form out loud using the rule-then-violation-then-fix structure, on several different sample tables.
Run an actual project's table design through normalization before writing the migration, catching redundancy issues before they become real bugs.
Build the conceptual foundation for why relational schemas are structured the way they are before working with existing normalized databases.
Discover more prompts that could help with your workflow.
Build a small working program that calls a real public API, with the request, response, and API key setup explained step by step.
Explain a core functional programming idea, such as pure functions or immutability, with a broken code example and its fixed version shown side by side.
Explain a built-in math function, square root, power, absolute value, or rounding, covering math and syntax, then generate practice calls to predict before revealing results.
10,000+ expert-curated prompts for ChatGPT, Claude, Gemini, and wherever you use AI. Our extension helps any prompt deliver better results.