Your checkout design is ready for handoff, but its use case descriptions don't say what happens when payment fails after the customer selects Place Order.
The engineer must choose whether to create an order, the designer must invent a recovery screen, and QA must guess what to test. If those decisions disagree, customers may see confusing statuses while the team untangles behavior after launch.
A better approach treats each description as a testable contract between product, design, engineering, and QA. With clear fields, observable steps, and explicit branch endings, you can turn a feature idea into behavior everyone can review before implementation.
Core Fields Every Use Case Description Needs
A use case description is a structured account of how an actor reaches a goal through a system, a concept introduced through Ivar Jacobson's Object-Oriented Software Engineering method and later incorporated into UML, as documented in the OMG UML specification.
Core fields in a use case description
| Field | Purpose | Example for Place Order |
|---|---|---|
| Identifier | Stable reference for traceability | UC-014 |
| Goal | The actor's outcome in one sentence | Customer receives a confirmed order |
| Scope | System boundary the use case covers | Online store checkout and payment |
| Primary actor | Person or system that starts the use case | Customer |
| Supporting actors | External systems used during the flow | Payment Service, Inventory Service |
| Trigger | Event that starts the flow | Customer selects Place Order |
| Preconditions | State that must hold before the flow starts | Cart holds at least one in-stock item |
| Main success scenario | Ordered actor and system exchanges on the normal path | Customer submits address, system validates it, payment authorizes, order is created |
| Alternate flows | Valid variations that still reach the goal | Customer selects a saved address |
| Exception flows | Failures and recovery behavior | Payment declined, customer retries or cancels |
| Postconditions | State guaranteed after completion | Order record exists with status Confirmed |
| Business rules | Constraints the flow must respect | Orders above a set value need approval |
| Assumptions | Conditions treated as true but not yet verified | Payment Service responds within an agreed time |
These values are hypothetical, not prescribed checkout behavior. Add links to higher-level requirements alongside the identifier so reviewers can trace the scenario to a business need, customer problem, or policy.
What standards establish
ISO/IEC/IEEE 29148:2018 defines requirements-engineering processes and requirements information items, including their contents and formats. It supports treating this document as a maintained requirements artifact, not an informal story.
Standards define recognized concepts and documentation expectations. They don't impose this exact table as a mandatory template for every project. Your team must still judge which fields need separate entries and how much detail reviewers need.
Fields that deserve extra attention
Scope prevents accidental promises. If payment authorization belongs to an external service, distinguish what that service returns from what your checkout guarantees.
Assumptions expose uncertainty. A response-time expectation isn't a verified service commitment merely because someone typed it into a template.
Traceability explains why the behavior exists. For a directory product, you might first compare essential directory platform features, then connect selected capabilities to concrete goals such as finding a provider or submitting a listing.
Practical rule: A filled cell isn't evidence of completeness. If a reviewer still can't name the starting state or testable outcome, the relevant field needs work.
Preconditions, Postconditions and Business Rules
Preconditions state what must already be true before execution. Postconditions state what the system guarantees when execution finishes, including defined failure outcomes.
A business rule governs which behavior is allowed. An assumption records something the team hasn't yet verified.
Hypothetical worked contrast
| Weak version | Strong version |
|---|---|
| Place order | Customer requests a confirmed order through checkout, using the Payment Service. |
| Starting state unstated | Cart contains valid, in-stock items before checkout begins. |
| Behavior unstated | Customer confirms the cart and address; the system validates details, requests authorization, and creates the order on success. |
| Failure outcome unstated | If payment is declined, no order is created and the cart remains unchanged. |
The strong version establishes a starting state, connecting actions, and an observable result. It also prevents a common mistake: treating successful completion as the only ending worth documenting.

Separate rules from guesses
Suppose the business requires approval for orders above a configured value. Name that rule, reference its authoritative policy, and attach it to the approval decision before payment authorization. Don't invent a threshold inside the use case.
Tax rules, eligibility checks, and purchasing limits need the same treatment. When writing a product requirements document, keep the policy's source clear so individual scenarios don't introduce conflicting versions.
By contrast, an expectation that inventory remains available throughout checkout is an assumption until someone validates it. Assign an owner to investigate it and specify what happens if it proves false.
Use this review checklist:
- Check each precondition. A reviewer must be able to establish whether it holds.
- Test each postcondition. Replace vague outcomes such as processed successfully with a verifiable state.
- Attach each rule. Identify the action or decision it constrains.
- Assign each assumption. Name who will validate it and record the resulting decision.
Writing the Basic Flow One Step at a Time
The basic flow is the ordered exchange that reaches the actor's goal without a variation or failure. Write it as observable behavior, not a description of the code you expect engineers to build.
The Visual Paradigm use case guide connects actors, boundaries, preconditions, flows, and postconditions into a complete behavioral specification. A feature name alone doesn't establish those connections.
Build the sequence
Step 1. Name the goal and primary actor.
Write a sentence such as Customer submits an expense report.
Avoid feature labels like expense management, which hide the intended outcome.Step 2. Record the trigger and starting state.
Separate the event that starts execution from conditions that already hold.
Customer selects Submit is a trigger; customer has a completed draft is a precondition.Step 3. Pair actor actions with system responses.
Write customer submits shipping address, followed by system validates the address.
Don't leave the reader guessing who performs an action.Step 4. Check that each result is observable.
A reviewer should be able to see the action or verify its outcome.
Replace system handles the request with the specific response it provides.Step 5. Remove implementation decisions.
Describe the required behavior without database calls, class names, or fixed screen layouts.
Keep technical constraints elsewhere unless they constrain the requirement.Step 6. Stop when the goal is achieved.
End at the stated successful outcome.
Don't combine ordering, shipment tracking, and returns merely because the same customer performs them.Step 7. Review the flow with engineering and QA.
Read it aloud and identify where each action could fail.
Capture those discoveries as named branches rather than expanding the basic flow into a maze.

Replace hidden work with visible behavior
Before: The checkout controller writes the address object to storage.
After: The customer submits a shipping address. The system validates it and presents the accepted address for confirmation.
The revised version leaves implementation flexible while specifying what the customer and tester can verify. It also exposes a useful question: what response appears when validation fails?
The basic gist is this: write what must happen, in the order it must happen, until the actor's goal is satisfied.
A diagram can help when sequence becomes hard to follow. These flowchart process examples offer a visual complement, but the written flow should still identify actions, responses, and the final state without relying on arrows alone.
Alternative and Exception Flows That Stop Surprises
Password reset branches, illustrative
| Branch | Starts at | What happens | Resumes or ends |
|---|---|---|---|
| Invalid email | After account lookup | Show neutral recovery message | Ends the use case |
| Expired reset token | At token validation | Offer a new token | Returns to verification step |
| Email delivery failure | After the link is sent | Show retry option | Returns to request step |
| Repeated failed attempts | At verification | Lock further resets for a set period | Ends the use case |
These are hypothetical product decisions, not universal password-reset requirements. For the invalid-email branch, a neutral response should avoid revealing whether an account exists. The lock period requires an approved security rule rather than an arbitrary duration chosen by the writer.
An alternative flow describes a legitimate variation, such as selecting a saved address. An exception flow describes failure and recovery, such as a rejected payment. Teams sometimes use alternative flow as an umbrella term, so establish your terminology before reviewing completeness.
Specify both ends of every branch
The use-case modeling guidelines hosted by Florida State University require alternative flows to identify entry and exit points. That means recording the initiating condition, actions, and whether execution returns to a particular step or terminates.
Consider the expired-token row. Offering a new token isn't a complete recovery path by itself. The description must say that the customer requests another token, receives a replacement through the defined delivery flow, and presents it for verification.
The email-delivery branch needs a detection boundary too. A system may know a provider rejected delivery, but it may not know that a message landed in spam. Specify the failure signal the system can observe.
Check the state after recovery
A retry must not leave the previous attempt in an ambiguous state. Record whether the old token becomes invalid, whether a request remains pending, and which state the user can safely continue from.
Every branch needs an ending, even when the ending is that the actor's original goal remains unmet.
For repeated failures, the terminal state might be reset temporarily blocked, password unchanged. That belongs among the failure postconditions, alongside successful reset behavior.
This is the practical value of documenting edge cases before development: design, engineering, and QA can review the same decisions instead of making separate assumptions.
Keep alternatives in named branches, not buried inside long basic-flow steps. Reviewers should be able to locate a condition and follow its consequences without reconstructing the entire scenario.
A Complete Sample for Place Order
Imagine a PM reviewing checkout with an engineer and a QA tester. The PM wants a confirmed purchase, the engineer needs to coordinate external services, and QA needs to distinguish a declined payment from an uncertain payment result.
The following hypothetical example makes those responsibilities visible. It covers the stated checkout scope, not every possible commerce requirement.
Use case UC-014
| Field | Description |
|---|---|
| Goal | Customer receives a confirmed order |
| Scope | Online store checkout and payment |
| Primary actor | Customer |
| Supporting actors | Payment Service, Inventory Service |
| Trigger | Customer selects Place Order |
| Preconditions | Cart holds at least one valid, in-stock item |
| Requirement reference | Checkout requirement for purchasing available goods |
| Business rules | Display the final total before authorization; apply any required approval before payment |
| Assumption | Payment Service responds within an agreed time, pending validation by the integration owner |
Main success scenario
Flow step A. Customer confirms the cart.
The system presents the items and quantities for review.
The customer confirms the intended purchase.Flow step B. System presents totals.
The system calculates and displays the payable total.
Any required approval is resolved before authorization proceeds.Flow step C. Customer submits a shipping address.
The system validates the address.
The customer corrects any invalid details through a named validation branch.Flow step D. System requests payment authorization.
The Payment Service authorizes the displayed amount.
The system associates the authorization with this purchase attempt.Flow step E. System reserves inventory and confirms the order.
The Inventory Service confirms the reservation, and the system creates the order record.
The system presents the order identifier and Confirmed status.
Branches and guarantees
Alternate flow A1, saved address: At flow step C, the customer selects a saved address instead of entering one. The system validates that address and resumes at flow step D.
Exception flow E1, payment declined: At flow step D, the Payment Service declines authorization. The system displays a safe, actionable reason; the customer retries with another method at step D or cancels with the cart unchanged.
Boundary flow E2, inventory unavailable: At step E, reservation fails. The system does not confirm an order, releases any authorization through the payment recovery process, and reports the unavailable items.
Boundary flow E3, payment outcome unknown: At step D, the service times out without a definitive result. The system marks the attempt as awaiting reconciliation and prevents a fresh authorization until its outcome is resolved.
Success postconditions: An order record exists with status Confirmed, inventory is reserved, and the authorization belongs to that order. On cancellation after a decline, no confirmed order exists and the cart remains unchanged.
The testability check is concrete: QA can inspect order status, reservation state, authorization association, and retained cart contents.
Include, Extend and How Much Detail to Write
Choosing between include, extend and separate use cases
| Relationship | Meaning | Ask yourself | Example |
|---|---|---|---|
| Include | Base use case requires the behavior every time | Does the goal fail without this behavior? | Place order includes Calculate total |
| Extend | Behavior is added at an extension point | Does the base still succeed without it? | Apply promotional discount extends checkout |
| Separate use case | A complete user-visible goal of its own | Would an actor name this as a goal? | Submit expense report, not each click |
Include and extend are UML relationships, not informal synonyms for related functionality. Microsoft's UML use-case diagram guidelines distinguish required included behavior from conditional extensions whose base use case remains independently complete.
Apply the dependency test
Suppose someone models Calculate total as an extension of Place Order. That would imply the base checkout can succeed without calculating its payable amount, which contradicts the intended behavior.
An include relationship is appropriate when the base requires that behavior and separating it serves a useful modeling purpose. You don't need an included use case merely because a calculation occurs.
A promotional discount is different. Checkout can complete without a promotion, while an eligible promotion adds behavior at a defined extension point before the final total is accepted. If the business instead requires a contractual discount for every eligible purchase, don't call it optional because some customers don't qualify.
The question is whether the base use case is complete without the extension, not whether a feature appears on every screen.
Choose useful granularity
A use case should cover a complete user-visible goal. Submit expense report is useful; click attachment button usually belongs inside its flow.
Split behavior when an actor can pursue it independently or when multiple use cases reuse it. Keep a short, local validation step inline when extracting it would force readers to jump between documents without gaining clarity.
OMG's UML specification defines actor participation and use-case relationships. The choice of how finely to divide your particular product remains practical judgment.
Model relationships to clarify dependencies, not to make the diagram look more sophisticated.
As teams grow, excessive decomposition creates coordination work: more identifiers to maintain, more references to reconcile, and more places for contradictory rules. Too little structure creates a different burden, forcing reviewers to search long flows for shared behavior.
Let diagrams summarize actors, scope, and relationships, while the text carries operational detail. During review, check that the diagram doesn't imply optional behavior where the written requirements make it mandatory.
Accessibility and Real-World Variations to Document
Checkout fails on an invalid address, and the only signal is a red outline. A mouse user can guess the field. A keyboard user, or someone on a screen reader, may never land on a message that names the problem. The order is not placed, yet a vague postcondition (“the customer is informed”) still looks satisfied. That missing exception is how a use case passes review and fails after launch.
An ACM accessibility paper draws on 25 interviews with disabled people. It explains accessibility through barriers, available assistive technologies, and the context around the task, and its case studies look at how teams recognize the value of accessibility and where implementation skill is uneven.
Put the variation on the step you are specifying, the way a contract clause names the party and the remedy. Who is blocked, such as someone who cannot perceive the validation message? Which context changes the step: assistive technology, input method, device, or environment? If it fails, what progress is kept, and what recovery can that person use? What result can a tester observe with the same method?
One acceptance line pins it down: after an invalid address, a keyboard user reaches the error, corrects the field, and keeps the rest of the form. Repeat that recovery with the assistive technology you support. For a global SaaS product, low bandwidth, mobile-only access, localized content, and a temporary impairment can change what counts as a usable response.
Understanding the difference between A, AA and AAA helps a team choose the WCAG criteria that apply. The use case still has to state the behavior that shows conformance. Attach conditions to branches you already have. Copy the whole checkout for each input method only when the goal or the overall behavior changes. Otherwise the copies drift, and two documents describe one contract.
Governing AI-Drafted Use Cases Before Acceptance
A generated Place Order description can look finished and still fail as a requirement. It says the customer pays and the order is confirmed, yet never states what "confirmed" means if authorization times out. The missing exception branch and the vague postcondition are unsigned clauses. After launch, engineering and support have to invent the outcome, often by charging again on retry.
A use case description works like a contract a tester can enforce. Actors, steps, and terminal states are the terms. If a reviewer cannot mark a branch pass or fail without guessing, the draft is not ready.
An ACM study involving 17 product managers examined poorly defined agile epics and tested a quality rubric and an LLM-based evaluator, while recognizing limits in real product work. Clean prose did not, by itself, make those epics checkable. A 2025 arXiv industry survey found 58.2% of 55 surveyed software-engineering practitioners actively using AI in requirements engineering. That small sample provides context, not a population-wide adoption estimate.

Apply an acceptance gate
Walk the draft the way you would walk a form before signing it. Each field needs an owner and a way to tell fact from guess.
- Preserve the evidence. Link the scenario to customer observations, product constraints, or approved policy.
- Separate fact from inference. Label generated assumptions rather than presenting them as observed behavior.
- Assign a human owner. Give someone responsibility for resolving uncertainty and approving the description.
- Challenge missing behavior. Test for absent actors, authorization, privacy, edge cases, and failure recovery.
Return to the Place Order draft that covers declined payments and skips payment timeouts. Ask what an unknown authorization means. The basic flow can stay. The exception must name the guarantee: no second charge, an order that stays unchanged or explicitly pending, and a recovery step the customer can see. That is the difference between a story that sounds complete and a postcondition a tester can run.
For regulated, safety-critical, or high-impact workflows, AI should not make the final acceptance decision. Keep qualified human review and the applicable approval process.
Measure completeness, version the rationale, and retain links to supporting evidence. Accept the requirement because reviewers can verify its behavior, not because its prose sounds confident.
Frequently Asked Questions
How is a use case description different from a user story?
A user story names a role, goal, and benefit; a use case description specifies the interactions and outcomes needed to achieve that goal. Use a story to frame value and a description when teams need agreement on branches, responsibilities, and guarantees.
How long should a description be?
Make it long enough to cover the basic flow, meaningful branches, and terminal states. Split it when it combines independent goals. Shortening wording helps readability, but removing unresolved behavior only moves decisions into implementation.
Is a diagram enough?
A diagram usually isn't enough to specify operational behavior. It helps reviewers see participation and relationships, but textual detail explains conditions, recovery, and guarantees. Review both artifacts together whenever a relationship or system boundary changes.
How many alternate flows are enough?
You have enough when each identified variation has a named branch or an explicit condition in an existing branch. Don't chase an arbitrary count. Review plausible failures with domain specialists and record unresolved questions rather than assuming coverage.
Can a use case be reused across projects?
Yes, when its goal, actors, boundaries, and guaranteed outcomes still match. Recheck policies, external-service behavior, accessibility conditions, and assumptions before reuse. Similar feature names don't establish that the underlying contracts are equivalent.
Audit One Existing Use Case This Week
Choose a use case associated with repeated clarification or rework. Set aside a review session with the document and reviewers from engineering and QA; no special tool is necessary.
Count missing fields.
Use the core-fields table as the checklist and record the baseline.
Count unstated information, not merely empty cells.Walk actions and branches.
Check the basic flow for responsible actors and observable results.
Count branch endings that leave the next state unclear.Challenge the guarantees.
Test preconditions, postconditions, and include or extend choices.
Add an accessibility condition and identify any AI-drafted passages and their human owner.Turn decisions into verification.
Use the agreed outcomes when writing effective test cases.
Repeat the count after revision.
For optional tool support, Figr can create user flows, state diagrams, edge case maps, and acceptance criteria before screens. We describe our edge case mapping as catching states a designer would miss; verify that claim against your audit. Our User Story Generator produces the format As a [role], I want [goal], so that [benefit], with 2 to 4 acceptance criteria per story.
The next review should show fewer missing fields and fewer unstated branch endings, not a longer document.
Bring one existing checkout, onboarding, or recovery requirement to Figr to explore its user flow, edge cases, and acceptance criteria before committing to screens. Compare the resulting artifacts with your audit baseline, then have engineering and QA approve the remaining behavioral decisions.
