1. Introduction

The requirements definition tells us what the system should do. UML (a standard accepted by the OMG, Object Management Group) organizes these requirements as:

  • Use-case diagrams
  • Activity diagrams
  • Use-case descriptions

From requirements to functional models

  1. Develop use cases from the requirements — how the system interacts with users; a diagram (visual) + description (text) of discrete user activities.
    e.g., “User logs in”, “Customer places order”.
  2. Develop activity diagrams from the use cases — business processes step by step, plus the movement of objects (data) between steps.
    e.g., Login → Validate → Show dashboard.

⚠ Use-case + activity diagrams are logical models: they describe what happens, not how it’s implemented. The same model works whether the system is manual or automated.

ArtifactGives you
Use-case diagramBig picture / bird’s-eye view (overview)
Activity diagramDetailed steps inside each process (detailed flow)
Use-case descriptionFull textual documentation

2. Business Process Identification with Use-Case Diagrams

Definition (Use case)

Describes how the system behaves from the user’s perspective after the user requests a specific action.

  • Focuses on a single action (login, place order).
  • Shows only visible steps — what the user sees, not the code/database/logic inside.

2.1 Elements of a Use-Case Diagram

ElementRulesNotation
ActorPerson or system that derives benefit from and is external to the subject; labeled with its role; placed outside the boundary; can specialize another actor (hollow arrowhead)Stick figure, or rectangle with <<actor>> for non-human
Use caseA major piece of functionality; placed inside the boundary; labeled with a verb–noun phrase; can include/extend another use caseOval
Subject boundaryName inside or on top; represents the scope (a system or a single business process)Rectangle
AssociationLinks an actor with the use case(s) it interacts withSolid line (with multiplicities, e.g. *)
IncludeBase use case always uses the included one; arrow from base → usedDashed arrow <<include>>
ExtendOptional behavior; arrow from extension → baseDashed arrow <<extend>>
GeneralizationSpecialized use case (or actor) → general oneSolid line, hollow triangle at the general end

⚠ Arrow directions are the classic trap: include points to the included use case; extend points to the base use case.

2.2 Example 1 — Appointment System

flowchart LR
    Patient(["🧍 Patient"])
    Management(["🧍 Management"])
    Doctor(["🧍 Doctor"])
    subgraph AS[Appointment System]
        MA((Manage Appointments))
        PS((Produce Schedules))
        RA((Record Availability))
    end
    Patient ---|"* — *"| MA
    Management ---|"* — *"| PS
    Doctor ---|"* — *"| RA

Extending it with include / extend / generalization:

flowchart TB
    subgraph AS[Appointment System]
        MA((Manage Appointments))
        MOA((Make Old Patient Appt))
        MNA((Make New Patient Appt))
        UPI((Update Patient Information))
        MPA((Make Payment Arrangements))
    end
    MOA -->|generalization| MA
    MNA -->|generalization| MA
    MNA -.->|"«include»"| MPA
    UPI -.->|"«extend»"| MOA
  • Make New Patient Appt always requires payment arrangements → include (base → included).
  • Updating patient info happens only if it changed → extend (extension → base).
  • Both make-appointment use cases are special kinds of Manage Appointments → generalization.

2.3 Example 2 — Library Book Collection Management System

flowchart LR
    Librarian(["🧍 Librarian"])
    Borrower(["🧍 Borrower"])
    PO["«actor»<br/>Personnel Office"]
    RO["«actor»<br/>Registrar Office"]
    subgraph L[Library Book Collection Management System]
        POB((Process Overdue Books))
        MBC((Maintain Book Collection))
        BB((Borrow Books))
        SC((Search Collection))
        RB((Return Books))
    end
    Librarian --- POB
    Librarian --- MBC
    Borrower --- BB
    Borrower --- SC
    Borrower --- RB
    BB --- PO
    BB --- RO

Personnel Office and Registrar Office are non-human actors (external systems used to validate ID cards).


3. Business Process Modeling with Activity Diagrams

Activity diagrams can model anything from a high-level business workflow (many use cases) down to a single use case or even one method. This chapter focuses on high-level business processes.

  • A business process consists of several activities; the diagram shows their sequence.
  • Activity diagrams are:
    • Abstract — general processes, not details
    • Independent of objects — behavior, not structure
    • Flexible — any type of process

3.1 Elements of an Activity Diagram

ElementMeaningNotation
ActionSimple, non-decomposable piece of behavior; labeled verb + nounRounded rectangle
ActivityA set of actions — can be subdividedRounded rectangle
Object nodeAn object connected to object flows; labeled with class nameRectangle (name underlined)
Control flowSequence of execution; attaches only to actions/activitiesSolid arrow
Object flowFlow of an object between actions/activitiesDashed arrow
Initial nodeBeginning of the actionsFilled circle ●
Final-activity nodeStops all control and object flowsBull’s-eye ◉
Final-flow nodeStops one specific flowCircle with ✕
Decision nodeTest condition — flow goes down only one path; branches labeled with [guard]Diamond (1 in, many out)
Merge nodeRejoins paths created by a decisionDiamond (many in, 1 out)
Fork nodeSplits into parallel/concurrent flows (all paths run)Thick bar (1 in, many out)
Join nodeRejoins parallel flows into oneThick bar (many in, 1 out)
SwimlaneRows/columns assigning activities to the responsible person/objectLabeled lane

⚠ Decision vs. fork: decision paths are mutually exclusive (one is taken); fork paths are not (all run concurrently). Merge pairs with decision; join pairs with fork.

3.2 Guidelines for Creating Activity Diagrams

  1. Set the scope of the activity being modeled.
  2. Identify the activities; connect them with flows.
  3. Identify any decisions.
  4. Identify potential parallelism.
  5. Draw the diagram.

3.3 Creating an Activity Diagram

  1. Choose a business process identified previously (review the requirements definition, use-case diagram, other documentation).
  2. Identify the set of activities.
  3. Identify control flows and nodes.
  4. Identify object flows and nodes.
  5. Lay out and draw (minimize crossing lines).

Worked example — Manage Appointments (built from the Make Old Patient Appt flow):

flowchart TD
    S((●)) --> G[Get Patient Information]
    G --> D1{Info changed?}
    D1 -->|"[yes]"| U[Update Patient Info]
    D1 -->|"[no]"| M1{" "}
    U --> M1
    M1 --> D2{Request type?}
    D2 -->|"[new]"| N[Make New Appointment]
    D2 -->|"[cancel]"| C[Cancel Appointment]
    D2 -->|"[change]"| CH[Change Appointment]
    N --> M2{" "}
    C --> M2
    CH --> M2
    M2 --> F[Provide Results to Patient]
    F --> E((◉))
    N -.->|object flow| AP[Appointment]
  • Info changed? and Request type? are decision nodes with guard conditions.
  • The empty diamonds are merge nodes bringing the branches back together.
  • Appointment is an object node reached by an object flow (dashed).

Worked example — Add Apartment (Campus Housing), a simple sequential flow:

flowchart TD
    S((●)) --> A[Capture Location] --> B[Capture Number of Bedrooms] --> C[Capture Monthly Rent] --> D[Add Apartment] --> E((◉))

4. Business Process Documentation with Use Cases and Descriptions

4.1 Use Cases (recap)

  • The starting point for all UML diagrams — everything else is built from them.
  • Depict activities performed by users: what the user can do and how the system responds.
  • Each use case describes only ONE function.

4.2 Types of Use Cases

By level of detail

  • Overview — high-level, basic info only; used early to understand requirements (big picture).
  • Detailed — complete and precise, includes all steps and flows; based on activity diagrams.

By purpose

  • Essential — what should happen; no technical details; implementation-independent.
  • Real — how it actually happens; includes tools, systems, concrete steps.
OverviewDetail
EssentialHigh-level overview of issues essential to understanding required functionalityDetailed description of issues essential to understanding required functionality
RealHigh-level overview of a specific set of steps on the real (implemented) systemDetailed description of a specific set of steps on the real (implemented) system

Example. “Customer pays for order” is essential. “Customer taps card on the POS terminal; terminal sends request to bank API” is real.

4.3 Elements of a Use-Case Description

  • Overview: Name, ID number, Type, Primary actor, Brief description, Importance level, Stakeholder(s) & interests, Trigger (what starts it; external or temporal).
  • Relationships: association, include, extend, generalization.
  • Flow of events:
    • Normal flow — usual set of activities
    • Sub-flows — pieces of the normal flow, to simplify it
    • Alternate / exceptional flows — non-normal or error cases
  • Optional characteristics (complexity, time, …).

4.4 Use-Case Writing Guidelines

  1. Write clearly — subject–verb–object (“User enters password”).
  2. Show who acts — every step names its initiator (user or system).
  3. Stay neutral — independent observer’s view (no “I”/“we”).
  4. Same level of abstraction — don’t mix very detailed and very general steps.
  5. Complete transaction in four steps:
    1. Primary actor sends a request (with data) to the system.
    2. System validates the request.
    3. System processes it and may update its state.
    4. System returns the result to the user.
  6. KISS — Keep It Simple, Stupid.
  7. Iterate — review and refine until analysts and users agree there are enough use cases to start identifying candidate classes. New use cases may appear while identifying classes.

4.5 Creating Use-Case Descriptions

  1. Overview — primary actor, type, stakeholders & interests, importance, brief description, trigger, relationships.
  2. Normal flow — main steps.
  3. Keep steps simple — consistent size and level of detail.
  4. Alternate flows — exceptions and different paths.
  5. Review for correctness and completeness.
  6. Iterate.

4.6 Example 1 — Borrow Books

FieldValue
Name / ID / ImportanceBorrow Books / 1 / High
Primary actorBorrower
TypeDetail, Essential
StakeholdersBorrower — wants to check out books; Librarian — ensures borrower only gets books deserved
Brief descriptionHow books are checked out of the library
Trigger / TypeBorrower brings books to check-out desk / External
AssociationsBorrower, Personnel Office, Registrar’s Office

Normal flow

  1. The Borrower brings books to the Librarian at the check-out desk.
  2. The Borrower provides the Librarian their ID card.
  3. The Librarian checks the validity of the ID card:
    • Student → validate against Registrar’s database
    • Faculty/Staff → validate against Personnel database
    • Guest → validate against the Library’s Guest database
  4. The Librarian checks for overdue books and/or fines.
  5. The Borrower checks out the books.

Alternate/exceptional flows

  • 4a. ID card invalid → request rejected.
  • 5a. Overdue books or fines → request rejected.

4.7 Example 2 — Make Old Patient Appt

FieldValue
ID / Importance2 / Low
Primary actorOld Patient
TypeDetail, Essential
StakeholdersOld Patient — make/change/cancel an appointment; Doctor — patient’s needs met in a timely manner
Trigger / TypePatient calls to make, change or cancel an appointment / External
RelationshipsAssociation: Old Patient · Extend: Update Patient Information · Generalization: Manage Appointments

Normal flow

  1. Patient contacts the office regarding an appointment.
  2. Patient provides the Receptionist with name and address.
  3. If the Patient’s information has changed → execute Update Patient Information.
  4. If payment arrangements changed → execute Make Payment Arrangements.
  5. Receptionist asks: new, cancel, or change? → run S-1, S-2 or S-3.
  6. Receptionist provides the results to the Patient.

Sub-flows

  • S-1 New: ask for possible times → match with available slots → schedule.
  • S-2 Cancel: ask for old appointment time → find it in the file → cancel.
  • S-3 Change: perform S-2 then S-1.

Alternate flows

  • S-1, 2a1: Receptionist proposes alternative times.
  • S-1, 2a2: Patient picks one or decides not to make an appointment.

⚠ Notice how S-3 reuses S-1 and S-2 — sub-flows keep the normal flow short and avoid repetition.

4.8 Example 3 — Add Apartment (Campus Housing)

Use-case diagram, activity diagram and description all describe the same process:

flowchart LR
    AO(["🧍 Apartment Owner"])
    ST(["🧍 Student"])
    subgraph CHS[Campus Housing System]
        AA((Add Apartment))
        DA((Delete Apartment))
        SR((Search Available Rental Units))
    end
    AO --- AA
    AO --- DA
    ST --- SR
FieldValue
ID / Importance / Type1 / High / Detail, Essential
Primary actorApartment Owner
StakeholdersApartment Owner — advertise apartment; Campus Housing Service — enable owners to rent
TriggerApartment Owner wants to add an available apartment (External)
Normal flow1. Capture location · 2. Capture number of bedrooms · 3. Capture monthly rent · 4. Add apartment to the listing

Each activity in the activity diagram (§3.3) maps 1-to-1 to a normal-flow step — exactly what V&V checks below.


5. Verifying & Validating Functional Models

Use cases must be verified and validated before structural and behavioral modeling.

5.1 Walkthroughs

A review meeting of all diagrams and models by the development team and the client.

RoleResponsibility
FacilitatorOrganizes the meeting (schedule, set-up)
PresenterExplains the representation being reviewed
Recorder (scribe)Takes notes, records errors

5.2 Rules for V&V

#RuleCheck
1Match stepsEvery action/activity in the activity diagram appears in the use-case description’s flows
2Include all objectsEvery object node in the activity diagram is mentioned in the description
3Same orderDescription steps follow the activity diagram’s sequence
4One description onlyEach use case has exactly one description
5Actor consistencyAll actors in the description appear in the use-case diagram
6Stakeholders (optional, local policy)Stakeholders may also appear on the diagram
7Relationship consistencyAll relationships in the description appear in the use-case diagram
8Diagram rulesAll standard UML rules are respected

Worked example — checking Add Apartment

  • Rule 1 & 3: activities Capture Location → Bedrooms → Rent → Add Apartment = normal-flow steps 1→4, same order ✓
  • Rule 5: actor Apartment Owner is on the use-case diagram ✓
  • Rule 7: only an association with Apartment Owner — shown on the diagram ✓