5.2 Interaction Modeling (Sequence Diagrams)

Generating Sequence Diagrams Directly from Descriptions to Model the Order of Events

While Activity Diagrams excel at showing the internal workflow and decision logic of a use case from a process perspective, Sequence Diagrams provide a complementary, time-ordered view focused on interaction: who calls whom, in what sequence, with what messages, and how responses flow back. They are particularly valuable for:

• Understanding dynamic behavior between the system boundary, actors, and internal components
• Designing APIs, service interfaces, and message flows
• Clarifying responsibilities and dependencies across layers (UI → Controller → Service → Repository)
• Identifying synchronous vs. asynchronous calls, timeouts, and error propagation
• Supporting integration testing and debugging scenarios

In Visual Paradigm’s AI-Powered Use Case Modeling Studio, Sequence Diagrams are generated directly from the detailed textual use case specification (main success scenario + alternatives + exceptions) by selecting a use case and clicking “Generate Sequence Diagram” or “Visualize Interactions”. The AI parses:

• Each numbered step in the flows
• References to «include» sub-flows (treated as combined fragments or separate interaction occurrences)
• Extension points and conditional branches
• Actor-system and system-external system interactions
• Pre- and postconditions that imply state changes

It automatically creates:

• Lifelines for the primary actor, system boundary (often partitioned into UI/Controller/Service layers), secondary actors, and key internal objects
• Synchronous/asynchronous message arrows with operation names derived from verbs
• Return messages (dashed arrows) showing responses
• Combined fragments for loops, alternatives (alt), option (opt), parallel (par), or references (ref) to included behavior
• Activation bars indicating when a lifeline is processing
• Notes or guards for conditions, timeouts, or error cases

The generated diagram is fully editable: you can rename messages, add parameters/return types, change message style (synchronous → asynchronous), insert fragments, adjust layout, or add state invariants.

Practical Examples

Example 1: GourmetReserve – Use Case: Book a Table (Happy Path)

AI-Generated Sequence Diagram:

• Lifelines (left to right): Diner : MobileApp (UI) : ReservationService : PaymentGateway : NotificationService
• Key messages:
  1. Diner → MobileApp: searchTables(location, date, time, partySize)
  2. MobileApp → ReservationService: findAvailableSlots(…)
  3. ReservationService → MobileApp: return availableSlots[]
  4. MobileApp → Diner: displayResults(availableSlots)
  5. Diner → MobileApp: selectSlot(slotId, partySize)
  6. MobileApp → ReservationService: reserveAndPay(slotId, depositAmount)
  7. ReservationService → PaymentGateway: processPayment(depositAmount, cardDetails)
  8. PaymentGateway → ReservationService: paymentApproved(transactionId)
  9. ReservationService → MobileApp: reservationConfirmed(reservationId)
  10. MobileApp → NotificationService: sendConfirmation(reservationId) [async]
  11. MobileApp → NotificationService: scheduleReminder(reservationId, 24h before)
  12. MobileApp → Diner: showConfirmationScreen()
• Refinement you add:
  • Wrap steps 7–8 in an alt fragment: [payment approved] vs. [payment failed → show error & rollback]
  • Add activation bar on ReservationService during payment processing
  • Insert note on async messages: “Notifications sent via queue (fire-and-forget)”

Example 2: SecureATM – Use Case: Withdraw Cash

AI-Generated Diagram Highlights:

• Lifelines: Customer : ATMInterface : AuthService : AccountService : CashDispenser : FraudMonitor
• Sequence:
  1. Customer → ATMInterface: selectWithdraw()
  2. ATMInterface → AuthService: authenticate(pin, cardData) [include Authenticate User]
  3. AuthService → ATMInterface: authSuccess(sessionToken)
  4. Customer → ATMInterface: enterAmount(200)
  5. ATMInterface → AccountService: validateWithdrawalLimit(amount, sessionToken)
  6. AccountService → ATMInterface: limitApproved()
  7. ATMInterface → AccountService: debitAccount(amount + fee)
  8. AccountService → ATMInterface: debitConfirmed(newBalance)
  9. ATMInterface → CashDispenser: dispense(amount)
  10. CashDispenser → ATMInterface: dispensed()
  11. ATMInterface → FraudMonitor: logTransaction(amount, location, time) [async]
  12. ATMInterface → Customer: showSuccessScreen()
• Exception fragment (alt):
  • [insufficient funds] → AccountService → ATMInterface: insufficientFundsError()
  • [fraud detected] → FraudMonitor → ATMInterface: retainCard() → ATMInterface → Customer: securityMessage()

Example 3: CorpLearn – Use Case: Take Final Assessment

AI-Generated Sequence (excerpt):

• Lifelines: Learner : WebApp : AssessmentService : ScoringEngine : CertificateService : ProgressRepository
• Flow:
  1. Learner → WebApp: startAssessment(courseId)
  2. WebApp → AssessmentService: loadQuestions(courseId)
  3. AssessmentService → WebApp: return questions[]
  4. loop [for each question] Learner → WebApp: submitAnswer(questionId, answer) WebApp → AssessmentService: recordAnswer(…)
  5. Learner → WebApp: submitAssessment()
  6. WebApp → AssessmentService: submitForScoring()
  7. AssessmentService → ScoringEngine: calculateScore(answers[])
  8. ScoringEngine → AssessmentService: score = 85%
  9. AssessmentService → ProgressRepository: updateProgress(courseId, score)
  10. alt [score ≥ 80%] AssessmentService → CertificateService: generateCertificate(learnerId, courseId, score) CertificateService → AssessmentService: certificateUrl AssessmentService → WebApp: return success + certificateUrl else [score < 80%] AssessmentService → WebApp: return fail + retakeInfo
  11. WebApp → Learner: displayResults()
• Refinement example:
  • Add opt fragment around certificate generation: [compliance acknowledgments completed]
  • Insert timeout message after step 4 loop: “Session timeout → auto-submit current answers”

Best Practices for Sequence Diagram Generation & Refinement

• Choose appropriate lifeline granularity — Start with actor + system boundary; later refine to UI/Service/Repository layers.
• Name messages clearly — Use verb + noun (e.g., processPayment, not just pay).
• Use fragments wisely — alt for alternatives, opt for optional steps, loop for repetitions, par for parallelism.
• Show returns — Include dashed return arrows for synchronous calls to show data flow back.
• Highlight asynchronicity — Use half-arrow heads for fire-and-forget messages (e.g., notifications, logging).
• Add guards & notes — Clarify conditions, error codes, or non-functional aspects (e.g., “< 2s response time”).

By the end of Section 5.2, you will have precise, time-ordered interaction models that reveal exactly how components collaborate to realize each use case. These Sequence Diagrams are indispensable for API contract definition, integration planning, and understanding system dynamics — and thanks to AI generation, you reach this level of detail far faster than manual drawing. With both behavioral (Activity) and interaction (Sequence) views complete, you’re ready to define the static structure in Class Diagrams (next section).