Requirements Analysis

Ambiguity and Incomplete Requirements

Every requirements document is incomplete, and the ones that look complete are usually the most dangerous. This lesson teaches how to find ambiguity, how to classify it, how to decide whether to resolve it now or design around it, and how to write the assumption register that keeps the design honest.

Intermediate

Learning objectives

  • Distinguish ambiguity, incompleteness, inconsistency and incorrectness
  • Recognise lexical, syntactic and referential ambiguity in a requirements sentence
  • Choose between resolving a gap now, recording an assumption, or designing for tolerance
  • Write an assumption that states the alternatives considered and the cost of being wrong
  • Identify the three highest-cost ambiguities and resolve them deliberately
  • Recognise a requirement that is simply wrong about the business

Prerequisites

  • Business Rules and Constraints
  • Requirements Gathering

Introduction

Ask any experienced designer what the hardest part of the job is and the answer is rarely the diagram. It is that the requirements never say what they need to say, and everyone involved is convinced they already did.

The document says "a member may reserve a book". Fine. Does a reservation hold the physical copy, or just the title? Does it expire? Can two members reserve the same title? Can a member reserve a title they already have on loan? Is a reservation the same thing as a loan that has not started yet? Every one of those questions changes the schema, and the document answers none of them.

The beginner's response is to pick an answer and move on. That is not wrong — it is unavoidable, because a designer cannot wait for perfect information that will never arrive. The professional's response is to pick an answer and write down that a choice was made, along with the alternatives, the reason, and what it will cost if the choice was wrong.

The difference between those two responses is the entire content of this lesson. One produces a schema. The other produces a schema that a team can maintain, because when the inevitable surprise arrives, there is a record of what was assumed and why.

The four kinds of gap

"Bad requirements" is not one problem. It is four, and each has a different remedy.

The four defects

Ambiguity — the statement is clear but admits more than one reading. "A member may reserve a book."

Incompleteness — a case exists in the domain that the statement does not address. The document says how loans are created and says nothing about what happens when a copy is lost.

Inconsistency — two statements cannot both be true. "A copy belongs to one branch" and "a copy may be transferred between branches while on loan".

Incorrectness — the statement is unambiguous, complete and consistent, and describes something the business does not do. "Members are identified by their email address", when the library has issued membership numbers for thirty years and half the members have no email.

The remedies differ sharply:

Defect Detectable by Remedy Cost if missed
Ambiguity Reading the same sentence twice, in two ways Ask; or assume and record Wrong cardinality; the schema cannot hold the real data
Incompleteness Enumerating cases systematically Ask; or design a tolerance A whole class of events has no representation
Inconsistency Cross-checking statements against each other Escalate to a decision-maker The schema satisfies one statement by violating another
Incorrectness Comparing the document with observed reality Show the document to the person who does the work A schema that is right about the document and wrong about the business

Incorrectness is the most dangerous, because none of the usual techniques find it. You cannot detect it by careful reading — the text is perfectly clear. You find it only by looking at how the work is actually done: the existing spreadsheets, the paper forms, the screenshots of the old system, the person who says "no, we have never done it that way".

Three levels of ambiguity

Ambiguity is not a single phenomenon either. It occurs at the level of the word, the sentence, and the reference.

Lexical ambiguity — the word means two things

The same word names two different concepts. This is the defect the glossary exists to prevent, and it is why that lesson came before this one.

Word Reading A Reading B Consequence for the schema
book The title, the abstract work The physical copy on the shelf One entity or two — the single most consequential decision in a library model
member Anyone registered Anyone with a currently valid card Whether Member needs a status and whether expired members are kept
loan The transaction The period the copy is out Whether a renewal is a new loan or a modification
available Present in the branch Not currently on loan Whether availability is stored or derived
fine The amount owed The charge that generated it One entity or two
order The customer's request The purchase from the supplier Two entirely different entities

Lexical ambiguity is resolved by the glossary, and the resolution is a naming decision: pick one meaning, give it the canonical term, and rename the other. What you must not do is keep the word and hope.

Syntactic ambiguity — the sentence parses two ways

The words are unambiguous; the structure is not.

"Each order is assigned to a warehouse and a courier is notified."

Two readings: (a) each order is assigned to a warehouse, and additionally a courier is notified about something; (b) each order is assigned to a warehouse and to a courier. The second reading makes courier an association of Order. The first leaves it as a notification process outside the schema.

"Members can borrow up to five books, or more with staff approval."

The scope of up to five is unclear: five per visit, five at a time, five per month? Each gives a different rule and a different enforcement.

"Books published before 1900 and donated are catalogued separately."

Does and join two conditions (both must hold) or list two categories (either)? The answer changes whether the entity has one flag or a subtype.

Syntactic ambiguity is resolved by rewriting the sentence into the rule register's form — one rule per sentence, with explicit quantifiers. If the rewrite needs two sentences, the original was two requirements.

Referential ambiguity — the reference is unclear

The sentence contains a reference whose target is not determined.

"When a copy is returned late, the member is charged a fine and the librarian is informed."

The librarian — which one? The one at the desk, the one who made the loan, the branch manager? If the answer is "the one at the desk", there is nothing to model, because it is whoever is present. If it is "the one who made the loan", Loan needs a staff association, and the schema changes.

"Its status is updated automatically."

Its — the loan's or the copy's? The copy's status is derivable from its loans, so storing it is a redundancy; the loan's status is not derivable. The pronoun hides a design decision.

Referential ambiguity is resolved by replacing every pronoun with its noun in the rewritten version. It sounds mechanical and it finds real defects: in a document of forty pages, the exercise typically produces a dozen questions.

Why requirements are incomplete

Incompleteness is not a failure of effort. It has structural causes, and knowing them tells you where to look.

Tacit knowledge. People cannot describe what they do automatically. Ask a librarian how a loan is recorded and they will describe the normal case; the case where the member's card is damaged and the number must be read from the register is not "how loans are recorded", it is just something they do.

The vocabulary gap. The domain expert has no word for the distinction the designer needs. They say "the book" because in their world the title and the copy are the same thing until the moment a second copy arrives.

The moving target. The business changes while the system is being built. The requirements were accurate in March; it is now November.

The unenumerated edge cases. Nobody lists the cases where the process fails, because the process is defined by the cases where it works. This is why the eight question templates from the previous lesson, and especially "what can never happen", find so much.

The absent stakeholder. The people who know about the edge cases were not invited, or were invited and did not speak.

Enumerating the cases systematically

The single most effective technique against incompleteness is to walk the lifecycle of each entity and ask what happens at each step. For Loan:

Step Question Typical gap found
Creation Who may create it, and what must be true first? Expired membership; copy already on loan; member at limit
Normal progress What changes during it? Renewals — how many, by whom, with what effect on the due date
Early termination Can it end before the due date? Return, and whether the copy's condition is recorded
Late termination What happens after the due date? Fines: how computed, capped, waived, paid
Abnormal termination What if the copy is lost or damaged? A state the document never mentions
Cancellation Can it be undone? A loan created in error
History What must be kept, and for how long? Legal retention; whether old loans are ever purged

Seven steps, seven opportunities for a gap, and in practice at least two of them will be missing from the document. Do this for every entity and the incompleteness becomes visible instead of latent.

Three responses to a gap

When a gap is found, there are exactly three honest responses and one dishonest one.

Response 1 — Resolve it now

Ask the person who knows. This is always the first thing to try, and it is astonishing how often it is skipped because the designer does not want to look uninformed.

The disambiguation ladder, in order:

  1. Ask the person who does the work. Not the manager — the person who stamps the forms. They know the exceptions.
  2. Look at the existing data. The current spreadsheet, the paper register, the old database export. Real data answers questions that interviews cannot: whether the field is ever empty, whether the code is ever reused, whether the same person appears twice.
  3. Look for precedent. If the organisation already runs a similar process elsewhere, its rules are probably the intended ones.
  4. Choose the reading that is more general, if nothing else works. A model that admits both readings will survive; one that admits only one will need changing.

Response 2 — Decide by assumption, and record it

When the answer is not available in time — the stakeholder is on holiday, the decision needs a committee, the deadline is Friday — assume, and write the assumption down in a form that a future reader can act on.

An assumption that is worth writing has six parts:

Part Example
The question Does a reservation hold a specific copy or only a title?
The alternatives (a) reserves a copy — needs Reservation → Copy; (b) reserves a title — needs Reservation → Title
What we chose (b), reserves a title
Why The document says "reserve a book", and members do not care which copy they get
Cost if wrong Moderate: adding copy_id to Reservation is an added nullable column and a rule change; existing rows would need a backfill
Who can confirm, and when Head librarian, next review, 12 March

The cost if wrong field is the one that makes the register useful for planning, because it tells the next reader whether the assumption is worth revisiting urgently or can wait.

Response 3 — Design for tolerance

Sometimes the answer is genuinely unknowable at design time, and the right move is to build a schema that accommodates both readings cheaply.

The classic case is one-to-many versus many-to-many. A department has employees; can an employee belong to more than one department? Nobody knows, and the answer will not arrive before the deadline. Two designs:

  • One-to-many: employee.department_id. Simple, fast, but adding a second department later requires a new table, a data migration and changes to every query.
  • Many-to-many: a belongs_to table. Slightly more complex, costs a join on every read, but accommodates the one-to-many case perfectly — you simply never insert a second row.

The asymmetry is decisive. The many-to-many model handles both answers; the one-to-many model handles one answer and needs surgery for the other. When the ambiguity is "one or many?" and the cost of the general model is a join, build the general model. It is not over-engineering; it is buying an option cheaply.

The same reasoning applies to:

Ambiguity Narrow model Tolerant model Verdict
One or many departments? FK on employee Join table Tolerant — the join is cheap
Is the middle name optional? NOT NULL Nullable Tolerant — a null costs nothing
Is the phone number multivalued? One column Separate table Depends — usually tolerant
One or two addresses? Two columns (home, work) Address entity with a type Depends — two columns collapse badly at three
Is the status a fixed list? ENUM Lookup table Tolerant if the list will grow

But tolerance is not free and it is not always right. A tolerant model that accommodates cases the business will never have is speculative generality, and it costs clarity, joins and indexes forever. The rule of thumb: tolerate when the general model costs a join or a nullable column; do not tolerate when it costs a new entity, an extra level of indirection, or a polymorphic structure.

The three ambiguities that cost the most

Of all the gaps a designer will meet, three account for most of the rework. Learn to spot them and to resolve them deliberately.

Ambiguity 1 — one-to-many or many-to-many

The most common, the most consequential, and the one stakeholders answer inconsistently on different days.

"A student enrols in courses." Can a course have many students? Obviously. Can a student have many courses? Obviously. So it is many-to-many — but the word enrols in a different sentence might mean "is assigned to a class group", which is one-to-many.

The diagnostic is always the same, and it must be asked in both directions:

Can one A have many B? and Can one B have many A?

Ask only one direction and you get the wrong answer half the time, because the natural reading of a sentence is asymmetric even when the domain is not.

Ambiguity 2 — optional or mandatory

"Every order has a customer." Certainly. "Every customer has an order." Almost certainly not — a customer may register and never buy.

The two directions are different rules and they are constantly conflated. In the E-R model they are two different minimum cardinalities; in the relational model one is NOT NULL and the other is a deferred constraint or nothing at all.

The cost of getting it wrong is asymmetric too. Declaring something mandatory that is optional means the system cannot record a legitimate state — a new librarian who has not yet made a loan, a product that has not yet been ordered. That is a data loss bug, and it surfaces as a support ticket in week one. Declaring something optional that is mandatory means the system accepts bad data, which surfaces months later as a report that does not add up.

Prefer optional when uncertain. Bad data can be cleaned; data that could not be entered cannot be recovered.

Ambiguity 3 — one entity or two

"A book has copies." One entity or two? "An employee is also a manager." One entity with a recursive relationship, or two entities?

The tests from the earlier lessons apply: does the candidate have its own identity, its own attributes, its own relationships, and is it referred to independently? But the decisive question is often simpler:

Will the organisation ever need to talk about one of them without the other?

The library talks about titles in the catalogue and about copies at the desk, and the two conversations have different attributes and different rules. Two entities. An order line always belongs to one order and is never discussed alone. One entity (or an attribute set on the order).

A fourth, sneakier one — is this an entity or a state?

"A reservation becomes a loan when the book arrives." If that sentence is taken literally, Reservation and Loan are the same entity with a status. If not, they are two entities with a transition between them.

The diagnostic: do they have different attributes? A loan has a due date and a return date; a reservation has an expiry and a queue position. Different attributes, different rules, different relationships → two entities. Merging them produces a table in which half the columns are null for half the rows, which is the classic symptom of an unresolved state-versus-entity ambiguity.

Worked example: six ambiguities in one paragraph

Here is a paragraph from the Library Management System requirements, as it was actually written in the first interview.

"Members can reserve books that are currently on loan. When the book comes back the member is notified and has three days to collect it. If they do not, the reservation is cancelled and the next member in the queue is notified. Staff can override the three-day limit."

Six sentences of clear English. Six ambiguities.

1. "reserve books" — lexical. Title or copy? The paragraph says "books that are currently on loan", which implies a specific copy is on loan — but a title with three copies may have two on loan and one on the shelf. Question: can a member reserve a title that is available right now? Resolution: assume a reservation is for a title, and that it becomes collectable when any copy is available. The queue is per title.

2. "the member is notified" — incompleteness. By what channel, and is the notification part of the schema? Resolution: the schema records the event — reservation.available_since — and the channel is out of scope for this system. Recording the date is essential; recording the channel is not.

3. "has three days to collect it" — syntactic. Three calendar days or 72 hours? From when — the moment the copy is returned, or the next opening time? Resolution: the rule register records "a collectable reservation expires 72 hours after it becomes available", and the ambiguity about opening hours is escalated because it changes behaviour on Fridays.

4. "the reservation is cancelled" — incompleteness. Cancelled by whom, and is it the same state as a cancellation by the member? Resolution: one status value expired distinct from cancelled, because the reports distinguish them and the member's history looks different.

5. "the next member in the queue" — referential and structural. The queue is a position, which means the model needs an ordering attribute on Reservation — a fact nobody would have guessed from the entity list. Resolution: Reservation.queue_position, or better, derive the position from reserved_at and record that the business accepts first-come-first-served. The choice matters: a stored position must be renumbered on every cancellation, a derived one cannot express a manual override.

6. "Staff can override the three-day limit" — family 6 from the previous lesson. Not expressible in the model. Resolution: the rule register records it as application-enforced, and the schema gains an extended_until attribute on Reservation so that the override has somewhere to live. Without that attribute the override is unrecordable, and staff will keep it on paper — which is how shadow systems are born.

Six ambiguities from five sentences, and every one of them changed either the schema or the rule register. That ratio is normal for a first-pass requirements paragraph.

When the requirement is simply wrong

Incorrectness deserves its own section because the remedy is uncomfortable: you have to tell someone that the document they signed is wrong.

Three signals that a requirement is wrong rather than merely unclear:

The existing data contradicts it. The document says every member has an email; the current spreadsheet has an email for 40% of them. Either the rule is new — in which case there is a migration project nobody mentioned — or the rule is wrong.

The people who do the work do not recognise it. Read the requirement aloud to the person at the desk and watch their face. "No, we don't do that" is the most valuable sentence in requirements analysis.

It describes a process nobody would design. A rule that requires the same information to be entered twice, or that forbids a case that obviously occurs, is usually a transcription of an old workaround rather than a rule.

The professional response is not to design around it silently. It is to write it down, show it, and ask. "The requirement says members are identified by email. Our records show 60% of members have no email. Which is correct?" — that question costs five minutes and can save a redesign.

Common mistakes

Mistake Symptom Consequence Fix
Assuming silently No record of any decision Nobody can tell a considered choice from an accident Record every assumption, however small
Asking only managers Document describes the process as designed, not as run Edge cases, workarounds and informal rules missing Interview the operational staff; look at the artefacts
Asking a cardinality in one direction "A course has many students" Wrong degree; missing join table Always ask both directions explicitly
Resolving ambiguity by choosing the narrower model One-to-many because it is simpler Every future many-to-many case needs surgery Tolerate when the general model costs only a join
Assuming mandatory when uncertain NOT NULL on a field that can legitimately be empty Legitimate states become unrecordable; data cannot be recovered Prefer optional; clean bad data later
Writing "to be clarified" A list of open questions that never closes The questions are forgotten; the schema encodes nothing Write a decision plus the cost of being wrong
Treating pronouns as harmless "its status is updated" A design decision is hidden in a pronoun Replace every pronoun with its noun
Not reading the existing data Interview-only requirements Rules that the data contradicts go unnoticed Always inspect the current spreadsheet or export
Confusing incompleteness with ambiguity Long list of "unclear" items Effort spent re-reading instead of enumerating cases Walk the entity lifecycle step by step
Escalating everything Every question becomes a meeting Design stalls; stakeholders disengage Resolve what you can; escalate only what is material

Summary

  • Requirements have four kinds of defect: ambiguity (more than one reading), incompleteness (a case is missing), inconsistency (two statements conflict), incorrectness (the statement is false about the business). The remedies differ.
  • Incorrectness is the most dangerous because careful reading cannot find it. Compare the document with the existing data and with the people who do the work.
  • Ambiguity occurs at three levels: lexical (the word means two things), syntactic (the sentence parses two ways), referential (the pronoun has no clear target). Rewriting — one rule per sentence, every pronoun replaced — finds most of it.
  • Incompleteness is structural, not a failure of effort. Enumerate cases by walking each entity's lifecycle: creation, normal progress, early and late termination, abnormal termination, cancellation, history.
  • There are three honest responses to a gap: resolve it now (ask, look at data, look for precedent, choose the general reading), assume and record, or design for tolerance. The dishonest one is to assume silently.
  • An assumption worth writing has six parts: question, alternatives, choice, reason, cost if wrong, who can confirm.
  • Design for tolerance when the general model costs a join or a nullable column — most famously one-to-many versus many-to-many, where the many-to-many model accommodates both answers.
  • The three costliest ambiguities are one-to-many versus many-to-many, optional versus mandatory, and one entity versus two. A fourth, subtler one is entity versus state.
  • When uncertain between optional and mandatory, prefer optional: bad data can be cleaned, data that could not be entered cannot be recovered.

Verification questions

1. A requirements document states: "A doctor works in a department." Which ambiguity is this, and how do you resolve it?

Show the solution

It is syntactic, and more specifically a missing cardinality — the sentence does not say whether the relationship is one-to-many or many-to-many.

Resolve it by asking both directions explicitly, not by inference from the sentence:

  • Can one doctor work in more than one department? (Very often yes: consultants, part-time staff, cross-covering.)
  • Can one department have more than one doctor? (Almost always yes.)

If both answers are yes, the relationship is many-to-many and needs a join. If the first is no and the second is yes, it is one-to-many and the department identifier goes on the doctor.

There is a third possibility the sentence conceals: "works in" might mean "is currently assigned to", which could be many-to-many over time — a doctor moves between departments and the history matters. That would make the association an entity with a start and end date. This is the same entity-versus-association test as before, applied to a sentence that looked settled.

If the answer cannot be obtained in time, design for tolerance: build the many-to-many. It handles the one-to-many case by never inserting a second row, and the cost is one join.

2. Why is "prefer optional when uncertain" the right default, when optional columns are usually criticised as a sign of a weak schema?

Show the solution

Because the two mistakes are not symmetric in cost.

Declaring a field mandatory when it is really optional means the system cannot record a legitimate state. A librarian cannot be registered before making a loan; a product cannot be created before being ordered; a member without an email cannot join. The data simply cannot be entered, so it is lost — and unlike bad data, it cannot be cleaned up later because it never existed.

Declaring a field optional when it is really mandatory means the system accepts incomplete records. That is a data quality problem, it is real, and it is fixable: find the nulls, chase them, add the constraint, migrate.

So the asymmetry is recoverable versus unrecoverable. Prefer the recoverable mistake.

The criticism of nullable columns is valid in a different context: a schema full of optional columns often means the designer never asked the question and made everything optional to avoid deciding. That is the silent-assumption failure, not the tolerance strategy. The distinction is that tolerance is a recorded decision with a stated reason and a plan to tighten the constraint once the answer arrives — and the assumption register should say exactly that.

3. You find that the current spreadsheet has an "email" column filled for only 40% of members, while the requirements say email is mandatory and unique. What do you do?

Show the solution

This is a signal of incorrectness, not ambiguity, and the first step is to establish which statement is false.

Three possibilities, and they are very different projects:

  1. The rule is new. Email is being introduced as mandatory, and the 60% without one must be collected. That is a data migration project with a deadline, an owner and a communication plan — not a schema decision. The schema can have NOT NULL only after the backfill.
  2. The rule is wrong. Email is optional, and the requirement was written by someone describing what they wish were true. The schema should have a nullable column with a unique constraint that tolerates nulls.
  3. The data is wrong. Members do have emails; the spreadsheet was never maintained. Then the question is where the real addresses are, and whether they can be recovered.

Do not choose between them. Present the finding with the number — "the requirement says mandatory; 60% of current records have no value" — and ask which is correct. That single question, asked before the schema is built, prevents either a failed launch (if you build NOT NULL and the migration does not happen) or a rule that nobody enforces (if you build it nullable and the business expected mandatory).

And record the answer as an assumption with a date, because whichever it is, someone will ask in a year why the column behaves as it does.

Exercise

Advanced

Interrogating a requirements paragraph

Below is a paragraph from the requirements of a car rental system, written by the operations manager in one sitting. It is typical: clear, confident, and containing at least eight defects.

"Customers rent vehicles from a branch. A rental has a start date and an end date, and the price is calculated from the vehicle category and the number of days. Customers may rent several vehicles at once on a single contract. Vehicles belong to a category, and each category has a daily rate. When a vehicle is returned, staff check the fuel level and record any damage. Damaged vehicles are sent to the workshop and are not available until repaired. Customers with a loyalty card get a 10% discount. Rentals can be extended if the vehicle is not booked by another customer."

Produce:

  1. A table of every defect you can find, classified as ambiguity (and at which level), incompleteness, inconsistency or incorrectness.
  2. For each defect, the specific question you would ask, and to whom.
  3. For each defect that cannot be resolved before the deadline, either the assumption you would record (with the cost of being wrong) or the tolerant design you would adopt.
  4. Identify which defects change the schema and which change only the rule register.
Commented solution

The defect table

# Fragment Defect Level / kind Question Asked to Schema or register?
1 "Customers rent vehicles from a branch" One-to-many or many-to-many? Can a customer rent from several branches, and can a branch serve many customers? Syntactic Can a rental start at one branch and end at another? Ops manager Schema — pickup/dropoff branches are two associations, not one
2 "a rental has a start date and an end date" Date or timestamp? Does the end date include the return day? Syntactic Is a rental of 1–3 March two days or three? Ops manager Register (billing rule) + schema (type choice)
3 "the price is calculated from the vehicle category and the number of days" Is the price stored or derived? If the rate changes, does a past rental change? Referential / derivation Should a historical invoice reflect the rate at the time? Finance Schema — snapshot the rate and the computed amount
4 "Customers may rent several vehicles at once on a single contract" Contract appears for the first time and is never defined. Is it an entity? Is a rental the same as a contract line? Lexical Is a contract a document that groups rentals? Can one contract be amended? Ops manager Schema — a new entity, Contract, which the entity list did not have
5 "Vehicles belong to a category" Can a vehicle change category? Is the category fixed at acquisition? Incompleteness Does a mid-life re-categorisation ever happen? Fleet manager Schema (whether the association is time-stamped)
6 "each category has a daily rate" One rate, or a rate that varies by season, branch or duration? Incompleteness Do rates change seasonally, and per branch? Finance Schema — a rate entity with a validity period instead of a column
7 "staff check the fuel level and record any damage" Fuel level is a measurement with a unit and a policy (full-to-full?); damage has a type, a severity, a cost, a photo Incompleteness What is the fuel policy, and is a damage report a separate document? Ops manager Schema — DamageReport as an entity; fuel as a number plus a policy attribute
8 "Damaged vehicles are sent to the workshop and are not available until repaired" State rule. Is in workshop a state of the vehicle? Who changes it? Can a vehicle be in workshop and reserved? Incompleteness (state) Which states does a vehicle have, and which transitions are legal? Ops manager Schema (status attribute) + register (transitions)
9 "Customers with a loyalty card get a 10% discount" Is the card an attribute, an entity, or a status? Does the discount apply to every rental or once? Can it combine with other discounts? Lexical / incompleteness Is the card a physical object with a number and an issue date? Are there other discount types? Marketing Schema — LoyaltyCard as an entity if it has a number and dates; a general Discount if there will be others
10 "Rentals can be extended if the vehicle is not booked by another customer" Extension is a modification or a new rental? Is the check on bookings, and what is a booking — is it different from a rental? Lexical + family 6 Is a booking the same as a reservation, and is a reservation a rental not yet started? Ops manager Schema (a reservation concept the document never named) + register (the check rule)
11 — Nothing is said about cancellations, no-shows, late returns, lost vehicles, or what identifies a customer. Incompleteness Walk the lifecycle of Rental and Vehicle Ops manager Schema and register both

The four defects that change the schema

  1. Contract does not exist in the requirements. Defect 4 is the most serious: "several vehicles at once on a single contract" introduces an entity that the rest of the document does not mention. A schema built from the entity list without reading this sentence would have Rental hanging off Customer and no way to group the rentals that share a contract — and the invoice, which is per contract, would be impossible.
  2. Rates are time-dependent. Defect 6. A daily_rate column on Category is the obvious model and the wrong one if rates change seasonally: the column holds today's rate, and every historical invoice silently becomes wrong. The correct model is a rate entity with a validity period.
  3. The price must be a snapshot. Defect 3. The computed amount and the rate used must be stored on the rental, for the same reason as the fine in the previous lesson.
  4. Pickup and dropoff are two associations. Defect 1. "rent vehicles from a branch" suggests one. One-way rentals are standard in the industry, and the sentence does not exclude them. Two associations, one of which may be optional.

The tolerant designs adopted without waiting

  • Defect 5 (category changes): make the association time-stamped — or, cheaper, record the category on the rental as a snapshot and treat the vehicle's current category as mutable. The second costs one column and survives either answer.
  • Defect 9 (discounts): model a Discount entity with a type and a value rather than a boolean has_loyalty_card. Costs one table, accommodates the almost-certain future of "students get 15%" and "long rentals get 5%".
  • Defect 2 (dates): use DATE for the rental period and record the billing rule in the register. Changing a type later is a migration; changing a rule later is a conversation.

The recorded assumption

For defect 10, the answer was not available before the deadline:

Assumption A-3. Extension of a rental. Question: is an extension a modification of the existing rental, or a new rental for the extra days? Alternatives: (a) modify end_date on the existing rental; (b) close the rental and create a new one. Chosen: (a), modify end_date. Why: the operations manager described it as "extending the rental", and the invoice is per contract, so a second rental would not change the billing. Cost if wrong: low to moderate. The schema is unaffected; the change is in the billing logic and in the history view, which would show one rental instead of two. Existing data would need a merge. Confirm with: operations manager, at the requirements review. Date: recorded with schema version 0.3.

What the exercise is really teaching

Eleven defects in five sentences — and four of them change the schema, including one that introduces an entity nobody had listed. The paragraph is not unusually bad. It is an ordinary paragraph written by a competent manager who knows the business and does not know what a schema needs.

That is the normal condition of requirements analysis. The job is not to receive complete requirements; it is to make the incompleteness visible, decide deliberately where it cannot be removed, and leave a record that the next person can act on.

Where to go next

Related lessons