Skip to content
Domain 2Task 2.1

Understanding Requirements

Learn this interactively

What You Need to Know

A requirement states what a system must achieve, do or have. Requirements belong to three layers. A business requirement says why the system exists. A functional requirement says what the system does to serve that outcome. An infrastructure requirement says what the platform must provide so that the behaviour continues to work under real load. Functional requirements describe behaviour. Non-functional requirements describe a quality of that behaviour, or a constraint on it.

This lesson uses one made-up example throughout: the engineering team at an online retailer, which is building a Claude assistant for order enquiries. The product specification mixes all three layers. The first skill in Domain 2 is to read the specification and put each requirement on the correct layer.

The Derivation Chain

Business: "halve the time customers wait for an answer about an order". Functional: "identify the order from the customer's message and route a return request to the right support team". Infrastructure: "absorb the documented Monday-morning enquiry peak inside the organisation's input-token-per-minute limit, and keep customer data in-region". In-region means that the data stays in the customers' own region, a constraint called data residency.

The chain runs one way. Business requirements produce functional ones. Functional requirements and the architecture produce infrastructure ones. If you skip a layer, or reverse the chain, a requirement has no source that it can be traced to.

The business layer can be recognised by its form. A statement that names no system behaviour and no platform property is a business requirement, however prominent its place in the specification is. "Halve the wait for an answer" names neither.

Functional Versus Non-Functional

The class depends on the kind of promise a statement makes, not on whether it contains a number. "Answer in the customer's language" promises behaviour, so it is functional. "First token within two seconds at Monday-morning peak" promises a quality of that behaviour under load, so it is non-functional. Latency targets, minimum throughput, availability, data residency, maximum cost and isolation guarantees are all non-functional, however many digits they contain. An isolation guarantee promises that one customer's data stays separate from another's. A number measures how well a behaviour happens. It does not add a behaviour.

There are two ways to confuse the two classes. Promotion is when you call the most specific, measurable statement functional because it is specific and measurable. Demotion is when you call a genuine behaviour a constraint because it sounds operational. An example is "route a return request to the right support team". Behaviour is functional. A quality or constraint on behaviour is not.

Rate Limits and Context Windows Are Requirement Inputs

Claude applications bring capacity constraints that most requirements processes have never had to model. The API enforces requests per minute (RPM), input tokens per minute (ITPM) and output tokens per minute (OTPM) per model class. So peak concurrency and prompt size become infrastructure requirements with documented numbers. A cache stores the start of a request, called the prefix, for reuse. Under the API's default rate limits, cache reads do not count toward ITPM, so the caching layer is part of the capacity question too.

The context window limits how much material one request can contain. This limit makes "summarise the customer's whole order history" a design input, not a phrasing choice.

Every API response reports your organisation's live limits in its headers.

python
import anthropic

client = anthropic.Anthropic()

response = client.messages.with_raw_response.create(
    model="claude-sonnet-5-5",
    max_tokens=256,
    messages=[{"role": "user", "content": "Reply with one word."}],
)

for name, value in response.headers.items():
    if name.startswith("anthropic-ratelimit-"):
        print(f"{name}: {value}")

The anthropic-ratelimit-* headers report the limit, the remaining allowance and the reset time for each enforced class. If you size peak load without checking these headers, you follow an anti-pattern. This anti-pattern assumes that production traffic will fit because the prototype traffic fit.

The Domain 5 boundary

Requirements NAME the constraint: the peak token throughput, the latency limits, the maximum cost. Choosing a model against that constraint is Domain 5's job. When model-selection language appears in a 2.1 question, the right answer states the requirement the model must satisfy, not the model.

The Architecture Decides Which Constraints Bind

Requirements are derived against the proposed solution architecture, never in isolation, because the architecture decides which constraints matter. A realtime interactive path, like the retailer's chat, has two constraints that must be met. One is time-to-first-token, the wait before the first part of the answer appears. The other is streaming support, which sends the answer as it is generated. An overnight batch path, such as sorting emailed enquiries, replaces those constraints with two others. One is the Batches API's 24-hour completion window. The other is its queue limits, which cap how many batch requests can be in the processing queue at once. With a caching layer, a repeated 30,000-token context, such as the retailer's returns and delivery policies, is not a throughput problem. It is a requirement on how to design the prefix (the start of each request, which the cache stores). The same business goal therefore produces different infrastructure requirements under different architectures.

In the exam

Domain 2 is 33.1% of the CCDV-F exam, which is about a third. The 2.1 questions are classification and derivation tests. They give a set of statements. They test whether you know which layer each statement is on and which layer it should come from. Answers that skip a layer or run the chain backwards are wrong.

The most common wrong option is promotion. Demotion also appears. The questions state the architecture, and the right answer is the matching requirement, not a generic checklist.

The harder type of question asks you to derive the requirement that the proposal implies but never states. Examples are data residency for a personalisation store and peak token throughput for a documented traffic spike. Its wrong options state requirements that the stated architecture does not need.

Exam Traps

Exam Trap

Classifying a latency target or minimum throughput as functional because it is the most measurable statement

Latency and throughput targets are non-functional: they constrain how well a behaviour performs and add no new behaviour. Measurability does not change that. Classify by what the statement promises.

Exam Trap

Answering a requirements question with a model recommendation when the scenario mentions latency or cost

Requirements name the constraint the platform must meet, such as a latency limit or a maximum cost. Choosing a model against it is Domain 5's job. Record the constraint, not the model.

Exam Trap

Treating rate limits and context windows as implementation details to discover during development

The limits are documented before any build exists. Discovering them in load testing means designing an architecture that may already violate them. Size peak concurrency and prompt size against them as requirements.

Practice Scenario

An independent publisher commissions a Claude-powered manuscript triage service. The commissioning document contains three statements: (1) reduce the backlog of unsolicited manuscripts; (2) extract genre, synopsis and rights metadata from each submission and route promising manuscripts to the matching editor queue; (3) handle the documented Friday-evening submission peak without exceeding the organisation's input-token-per-minute limit. How do these classify?

Build Exercise

Build Exercise

Derive the Chain for a Real Workload

Difficulty
25 minutes

What you'll learn

  • How to write a business requirement that contains no system behaviour
  • How to derive functional requirements a test could verify
  • How to derive infrastructure requirements against a stated architecture using documented limits
  • How to spot the requirement a proposal implies but never states
  1. Pick one Claude application you have shipped or scoped and write its business requirement in one sentence containing no system behaviour

    Why: The business layer is defined by what it lacks; writing it clean is the fastest way to internalise the clue the exam uses.

    You should see: One sentence naming an outcome, with nothing a system could implement or a test could verify.

  2. Derive two functional requirements from it, each naming an observable behaviour

    Why: Functional requirements are the testable middle of the chain, and deriving them from the outcome, rather than inventing them, is the direction that the right answers follow.

    You should see: Two statements a test could verify, each traceable to the business outcome.

  3. Sketch the solution architecture in three lines: which paths are interactive, which are batch, and where a cached prefix would sit

    Why: Infrastructure requirements are derived against an architecture, never in isolation; without this sketch the next step is guesswork.

    You should see: Three lines that make it obvious which constraints must be met.

  4. Against that architecture, derive two infrastructure requirements with real numbers from the rate limits page and the models overview

    Why: The exam frames rate limits and context windows as requirement inputs with documented values; using the real numbers builds the habit.

    You should see: Two statements naming platform provisions with figures: peak token throughput inside a documented limit, context budget inside a documented window.

  5. Classify every statement you wrote as business, functional or non-functional and infrastructure, fix any that belong to two layers at once, then write the one requirement the proposal implied but never stated

    Why: Implied-but-unstated is the harder question type for this sub-skill, and finding one in your own proposal proves that you can apply the skill outside the lesson.

    You should see: A clean classification and one new requirement, typically residency, isolation or a peak-load figure.

Sources