Practise vocabulary for database normalisation: 1NF, 2NF, 3NF, BCNF, and when to denormalise for performance.
0 / 18 completed
1 / 18
A table is in ___ Normal Form (1NF) when all columns contain ___ values and there are no repeating groups.
1NF requires each column to contain only atomic (indivisible) values — no arrays, no comma-separated lists in a single cell, no repeating column groups. Each row must be uniquely identifiable.
2 / 18
A table is in 2NF when it is in 1NF and every non-key attribute is ___ on the entire primary key, not just part of it.
2NF eliminates partial dependencies — non-key attributes must depend on the whole composite primary key, not just one part. Splitting out partially dependent columns into separate tables achieves 2NF.
3 / 18
A table is in 3NF when it is in 2NF and has no ___ dependencies — non-key attributes must not depend on other non-key attributes.
3NF eliminates transitive dependencies: A → B → C where B is a non-key attribute. Move B and C into a separate table to achieve 3NF. This reduces update anomalies.
4 / 18
___ is the deliberate introduction of redundancy into a schema to improve ___ performance, accepting the trade-off of update complexity.
Denormalisation adds redundant data (e.g., storing a computed total in the row) to avoid expensive JOINs. It trades write complexity (maintaining redundancy) for read performance — justified in read-heavy analytics schemas.
5 / 18
'This table has an update anomaly' means that updating one record requires ___ updates to avoid inconsistency.
An update anomaly occurs when the same information appears in multiple rows — updating one copy without updating all copies leaves the database in an inconsistent state. Normalisation eliminates update anomalies by removing redundancy.
6 / 18
Reviewer: 'Hey team, I've spotted a potential issue with the new user profile schema. The `user_details` table contains both `first_name` and `last_name`, but we're also storing address information directly within that same table. This seems like a classic case of denormalization—we might be impacting write performance later on if this table grows significantly. What's the *most* appropriate response to suggest during our code review?
The correct approach is to suggest splitting the table. Denormalization, while sometimes beneficial for read performance, can significantly complicate updates if data becomes inconsistent. Separating user demographics from address information will provide better control and reduce the risk of update anomalies. Options B and C represent incorrect responses – adding a new column exacerbates the problem, ignoring it is generally bad practice, and simply documenting doesn't solve the underlying design issue.
7 / 18
During a code review for the new `user_profiles` schema, Alice suggests adding a separate `address` table to avoid redundancy in the `user_details` table. Bob argues that denormalization is fine as long as it speeds up reporting queries. Which of the following statements best reflects the core reasoning behind Alice's suggestion?
The key issue with denormalizing data like this is the impact on update operations. Adding an `address` table introduces a join, which slows down updates to user details. Furthermore, it increases the risk of update anomalies – if an address changes, you need to update multiple records, potentially leading to inconsistencies. Alice's suggestion directly addresses these concerns by separating the data and minimizing the scope of updates required.
8 / 18
Reviewer: 'Hey team, I've spotted a potential issue with the new user profile schema. The `user_details` table contains both `first_name` and `last_name`, but we're also storing address information directly within that same table. This seems like a classic case of denormalization—we might be impacting write performance later on if this table grows significantly. What's the *most* appropriate response to suggest during our code review?
The correct approach is to suggest splitting the table. Denormalization, while sometimes beneficial for read performance, can significantly complicate updates if data becomes inconsistent. Separating user demographics from address information will provide better control and reduce the risk of update anomalies. Options B and C represent incorrect responses – adding a new column exacerbates the problem, ignoring it is generally bad practice, and simply documenting doesn't solve the underlying design issue.
9 / 18
During a code review for the new `user_profiles` schema, Alice suggests adding a separate `address` table to avoid redundancy in the `user_details` table. Bob argues that denormalization is fine as long as it speeds up reporting queries. Which of the following statements best reflects the core reasoning behind Alice's suggestion?
The key issue with denormalizing data like this is the impact on update operations. Adding an `address` table introduces a join, which slows down updates to user details. Furthermore, it increases the risk of update anomalies – if an address changes, you need to update multiple records, potentially leading to inconsistencies. Alice's suggestion directly addresses these concerns by separating the data and minimizing the scope of updates required.
10 / 18
Reviewer: 'Hey team, I've spotted a potential issue with the new user profile schema. The `user_details` table contains both `first_name` and `last_name`, but we're also storing address information directly within that same table. This seems like a classic case of denormalization—we might be impacting write performance later on if this table grows significantly. What's the *most* appropriate response to suggest during our code review?
The correct approach is to suggest splitting the table. Denormalization, while sometimes beneficial for read performance, can significantly complicate updates if data becomes inconsistent. Separating user demographics from address information will provide better control and reduce the risk of update anomalies. Options B and C represent incorrect responses – adding a new column exacerbates the problem, ignoring it is generally bad practice, and simply documenting doesn't solve the underlying design issue.
11 / 18
During a code review for the new `user_profiles` schema, Alice suggests adding a separate `address` table to avoid redundancy in the `user_details` table. Bob argues that denormalization is fine as long as it speeds up reporting queries. Which of the following statements best reflects the core reasoning behind Alice's suggestion?
The key issue with denormalizing data like this is the impact on update operations. Adding an `address` table introduces a join, which slows down updates to user details. Furthermore, it increases the risk of update anomalies – if an address changes, you need to update multiple records, potentially leading to inconsistencies. Alice's suggestion directly addresses these concerns by separating the data and minimizing the scope of updates required.
12 / 18
Reviewer: 'Hey team, I've spotted a potential issue with the new user profile schema. The `user_details` table contains both `first_name` and `last_name`, but we're also storing address information directly within that same table. This seems like a classic case of denormalization—we might be impacting write performance later on if this table grows significantly. What's the *most* appropriate response to suggest during our code review?
The correct approach is to suggest splitting the table. Denormalization, while sometimes beneficial for read performance, can significantly complicate updates if data becomes inconsistent. Separating user demographics from address information will provide better control and reduce the risk of update anomalies. Options B and C represent incorrect responses – adding a new column exacerbates the problem, ignoring it is generally bad practice, and simply documenting doesn't solve the underlying design issue.
13 / 18
During a code review for the new `user_profiles` schema, Alice suggests adding a separate `address` table to avoid redundancy in the `user_details` table. Bob argues that denormalization is fine as long as it speeds up reporting queries. Which of the following statements best reflects the core reasoning behind Alice's suggestion?
The key issue with denormalizing data like this is the impact on update operations. Adding an `address` table introduces a join, which slows down updates to user details. Furthermore, it increases the risk of update anomalies – if an address changes, you need to update multiple records, potentially leading to inconsistencies. Alice's suggestion directly addresses these concerns by separating the data and minimizing the scope of updates required.
14 / 18
Reviewer: 'The new `orders` table has columns for `customer_id`, `order_date`, and `total_amount`. We're also storing customer addresses directly within this table. This seems like a potential issue regarding data consistency.' What is the reviewer primarily concerned about?
The reviewer is highlighting a potential problem with data redundancy. Storing customer addresses alongside order information in the same table can lead to inconsistencies if an address changes; updating it requires multiple updates across all related orders. This introduces update anomalies and violates normalization principles.
15 / 18
Alex (Backend Engineer): 'I'm thinking of denormalizing the `product` schema to include frequently accessed category names directly in the product records. It might speed up queries.' What is Alex *primarily* considering when suggesting this approach?
Alex's suggestion focuses on improving query performance. Denormalization, in this context, involves adding redundant data (the category name) directly into the `product` table to avoid costly joins when retrieving product information frequently. This trade-off is often made to optimize read operations.
16 / 18
PR Description: 'Implemented denormalization of the `user_profiles` schema by adding a `last_name` column directly into the `user_details` table. This was done to optimize query performance for retrieving user profiles and reduce join complexity.' What is the *main* justification given in this PR description?
The PR description explicitly states that denormalization was implemented 'to optimize query performance.' This is the core reason for introducing redundancy – to speed up data retrieval by avoiding the need for complex joins between related tables. While other aspects might be considered, this is the primary justification.
17 / 18
Sarah (Data Engineer): 'I've been working on the new user schema and I'm considering denormalizing the address information. We're seeing slow queries when retrieving user profiles that need their addresses.' What is Sarah's *motivation* for discussing denormalization?
Sarah's statement directly links denormalization to a specific problem: slow queries retrieving user profiles. Her motivation is therefore focused on optimizing query performance – reducing latency by avoiding joins. This aligns with a practical need for faster data retrieval and highlights the benefits of denormalization in this scenario.
18 / 18
A database administrator is reviewing a schema design and identifies that a table contains multiple columns related to geographic location. They decide to create a separate `locations` table with a unique ID and store the latitude and longitude values in it. This approach is an example of:
This scenario demonstrates denormalization. By creating a separate `locations` table and linking it to the original table via a foreign key (the unique ID), redundancy is introduced to reduce join operations and improve query performance when retrieving location information. Full normalization would have involved multiple related tables.
What does the "Normalisation & Denormalisation Language" exercise practise?
Practise vocabulary for database normalisation: 1NF, 2NF, 3NF, BCNF, and when to denormalise for performance.
How many questions are in this exercise?
This exercise has 18 questions, each multiple-choice with a full explanation shown after you answer.
What English level is this exercise for?
This exercise is tagged Intermediate. If the vocabulary feels difficult, browse the Database Schema Design category page for an easier module to start with.
Is this exercise free to use?
Yes. Every exercise on CoderSlingo, including this one, is free with no account, sign-up, or paywall.
Do I get feedback if I answer incorrectly?
Yes — whichever option you choose, right or wrong, you'll immediately see an explanation clarifying the correct term and why the other options don't fit.
Can I retry this exercise?
Yes — once you finish all the questions, a "Try again" button on the results screen resets the exercise so you can practise as many times as you like.
Do I need an account to track my progress?
No account is required. Your progress bar and score for this session are tracked in the browser as you go, but nothing is saved once you leave the page.
Is "Normalisation & Denormalisation Language" part of a larger series?
Yes — it's one exercise in the Database Schema Design category on CoderSlingo. See the category page for the full list of related exercises on similar terminology.
Can I link directly to this exercise?
Yes — this exercise has its own permanent URL, so you can bookmark it or share the link directly with a colleague or study partner.
Where can I find more exercises like this one?
See the Database Schema Design category page for related exercises, or browse the main Exercises hub for other IT English topics.