Nikita Rykhlov

Posted on Jun 16

🏗️ Architecture: How to Visualize System Interaction - Use Case Diagram

#architecture #systemdesign #beginners #programming

A Use Case Diagram emerged as part of the Unified Modeling Language (UML), which was developed in the mid-1990s. The core concept was proposed by specialists Grady Booch, James Rumbaugh, and Ivar Jacobson, who worked at Rational Software at that time. By combining their approaches to object-oriented analysis and design, they created UML — a standard that became a universal tool for describing software system architecture. The Use Case Diagram became an important part of this language because it allowed visualizing how users interact with the system even at the requirements gathering stage.

What Is a Use Case Diagram?

A Use Case Diagram is one of the types of diagrams in UML that shows how different participants (actors) interact with the functionalities of a system. It helps visualize the main goals of users and define what actions the system must support to fulfill those goals.

Main Elements of a Use Case Diagram:

Actor — An external entity that interacts with the system. This can be a person, another system, or even time.

Use Case — A functionality or action provided by the system to the actor.

Relationships between actors and use cases — Indicate who participates in which action.

Relationships between use cases — Such as include, extend, and inheritance, which describe complex behavioral scenarios.

Why Use Use Case Diagrams?

Simplify communication with clients and stakeholders.
Help define the boundaries of the system.
Serve as a foundation for further design and testing.
Provide a high-level view of the system's behavior without diving into implementation details.

Example:

Imagine you are developing a platform for online food ordering. Your system should support features such as registration, menu browsing, placing orders, tracking deliveries, and rating orders. The actors may include: customer, courier, and restaurant.

Here’s how the textual description of this diagram might look:

PlantUML

@startuml
left to right direction
actor "Customer" as client
actor "Courier" as courier
actor "Restaurant" as restaurant

rectangle "Food Delivery Service" {
  client -- (Registration)
  client -- (Browse Menu)
  client -- (Place Order)
  client -- (Track Order)
  client -- (Rate Order)

  restaurant -- (Receive Order)
  restaurant -- (Prepare Order)

  courier -- (Receive Order for Delivery)
  courier -- (Deliver Order)
}

(Place Order) .> (Receive Order) : include
(Deliver Order) .> (Track Order) : extend
@enduml

How to Read This Diagram?

Customer can:
- Register in the app,
- Browse restaurant menus,
- Place orders,
- Track delivery status,
- Rate completed orders.
Restaurant is responsible for:
- Receiving order information,
- Preparing meals for delivery.
Courier is involved in:
- Receiving the order for delivery,
- Delivering the meal to the customer.

The include relationship shows that when a customer places an order, the restaurant always receives the order.
The extend relationship indicates that delivering the order may optionally be part of the tracking process.

Conclusion

A Use Case Diagram is a powerful tool for analyzing requirements and modeling system behavior in the early stages of development. It allows you to foresee key product features and understand how different users will interact with the system.

Use use case diagrams to better structure requirements, improve team communication, and create a clear vision of what your system should do.

📌 What do you think?

Have you ever created a Use Case Diagram for your projects?

What tools or notations do you prefer for modeling system behavior — PlantUML, draw.io, or something else?

👇 Share your thoughts and experience in the comments — I’d love to learn from you!

👍 If you enjoyed this article, don’t forget to like and share it — help others discover how to use Use Case Diagrams effectively!

DEV Community