Building a Robust ATM Cash Withdrawal Sequence Diagram in PlantUML

Step 1: Setting Up the Title and Automatic Step Numbering

I always begin my PlantUML diagrams by laying down clear global configurations. When modeling financial operations like an ATM withdrawal, keeping track of order execution is critical for both developers and auditors.

To achieve this, I start with the @startuml tag, define a descriptive title, and enable the autonumber feature.

@startuml
title ATM Cash Withdrawal Sequence Diagram

autonumber

Why use autonumber? Without automatic numbering, reviewers must manually trace sequence lines to understand order. Enforcing sequential numbering automatically indexes every request and response, making cross-referencing during architecture reviews completely effortless.

Step 2: Defining Actors and System Participants

Next, I identify the distinct entities participating in the transaction. I want to separate human actors from backend components and hardware subsystems.

Instead of letting PlantUML declare participants implicitly as messages are drawn, I explicitly define them at the top. This guarantees they appear in a logical, left-to-right order that reflects their architectural boundary:

actor Customer
participant "ATM Interface" as ATM
participant "Card Reader" as Reader
participant "Bank Server" as Bank
participant "Cash Dispenser" as Dispenser

Design Rationale:

• actor Customer: Represents the human user initiating the action.
• participant ... as Alias: Assigning short aliases like ATM, Reader, and Bank makes the rest of the script clean and readable without repeating long display strings.
• By placing Reader between Customer and ATM Interface, I accurately reflect the physical sequence of card insertion prior to software UI interactions.

Step 3: Modeling the Initial Authentication Flow

With participants declared, I begin mapping out the happy-path initialization: inserting the card, reading data, prompting for a PIN, and contacting the central bank server.

Customer -> Reader: Insert ATM Card
Reader -> ATM: Read Card Details
ATM -> Customer: Prompt for PIN
Customer -> ATM: Enter PIN
ATM -> Bank: Verify Card & PIN

Notice how synchronous messages use solid arrows (->). The card hardware triggers the ATM software, which prompts the user, captures input, and passes authentication credentials securely to the Bank server.

Step 4: Structuring Authentication Branching with alt Blocks

Real-world systems fail, and sequence diagrams must communicate error conditions explicitly. Once the ATM requests verification from the bank, two outcomes can occur: authentication fails or succeeds.

To represent conditional logic in PlantUML, I use an alt / else / end block:

alt PIN Invalid
    Bank --> ATM: Authentication Failed
    ATM -> Customer: Display "Invalid PIN" Message
    ATM -> Reader: Eject Card
    Reader --> Customer: Return Card
else PIN Valid
    Bank --> ATM: Authentication Successful
    ATM -> Customer: Prompt Transaction Selection & Amount
    Customer -> ATM: Select "Withdrawal" & Input Amount
    ATM -> Bank: Request Withdrawal Authorization (Amount)
    ...
end

Key Techniques Used:

• Dotted return arrows (-->) signal asynchronous response messages back to caller components.
• Clear block labels like [PIN Invalid] and [PIN Valid] instantly inform software developers how exception flows terminate (e.g., displaying error, ejecting card, and returning hardware).

Step 5: Nesting Logic for Account Authorization and Cash Dispensing

Once authentication is verified, the user requests a withdrawal. However, the bank must verify account balances and daily limits. To represent this secondary validation, I nest a second alt block inside the PIN Valid branch.

If funds are insufficient, the transaction terminates safely. If approved, the bank debits the account, triggers the cash dispenser, present cash, ejects the card, and offers an optional printed receipt.

    alt Insufficient Funds / Daily Limit Exceeded
        Bank --> ATM: Transaction Declined
        ATM -> Customer: Display Error Message
        ATM -> Reader: Eject Card
        Reader --> Customer: Return Card
    else Account Approved
        Bank -> Bank: Debit Account Balance
        Bank --> ATM: Transaction Approved

        ATM -> Dispenser: Dispense Cash
        Dispenser --> ATM: Cash Ready
        ATM -> Customer: Present Cash
        Customer -> ATM: Take Cash

        ATM -> Reader: Eject Card
        Reader --> Customer: Return Card
        ATM -> Customer: Print Receipt (Optional)
    end

Pro Tip: Notice the internal call Bank -> Bank: Debit Account Balance. Self-referencing arrows in PlantUML are ideal for highlighting internal backend state updates that don’t involve external network messaging.

The Complete PlantUML Script

Here is the full, assembled source code for our ATM Cash Withdrawal Sequence Diagram. You can copy and paste this code directly into your favorite free PlantUML editor to edit or render vector graphics:

@startuml
title ATM Cash Withdrawal Sequence Diagram

autonumber
actor Customer
participant "ATM Interface" as ATM
participant "Card Reader" as Reader
participant "Bank Server" as Bank
participant "Cash Dispenser" as Dispenser

Customer -> Reader: Insert ATM Card
Reader -> ATM: Read Card Details
ATM -> Customer: Prompt for PIN
Customer -> ATM: Enter PIN
ATM -> Bank: Verify Card & PIN

alt PIN Invalid
    Bank --> ATM: Authentication Failed
    ATM -> Customer: Display "Invalid PIN" Message
    ATM -> Reader: Eject Card
    Reader --> Customer: Return Card
else PIN Valid
    Bank --> ATM: Authentication Successful
    ATM -> Customer: Prompt Transaction Selection & Amount
    Customer -> ATM: Select "Withdrawal" & Input Amount

    ATM -> Bank: Request Withdrawal Authorization (Amount)

    alt Insufficient Funds / Daily Limit Exceeded
        Bank --> ATM: Transaction Declined
        ATM -> Customer: Display Error Message
        ATM -> Reader: Eject Card
        Reader --> Customer: Return Card
    else Account Approved
        Bank -> Bank: Debit Account Balance
        Bank --> ATM: Transaction Approved

        ATM -> Dispenser: Dispense Cash
        Dispenser --> ATM: Cash Ready
        ATM -> Customer: Present Cash
        Customer -> ATM: Take Cash

        ATM -> Reader: Eject Card
        Reader --> Customer: Return Card
        ATM -> Customer: Print Receipt (Optional)
    end
end

@enduml

Why Render Your Sequence Diagrams with VPasCode?

Creating complex diagrams using code shouldn’t require tedious local environment setups or manual command-line compilation. VPasCode by Visual Paradigm brings instant rendering and powerful AI assistance directly to your browser:

• Automatic Format Detection: Paste PlantUML, Mermaid, Graphviz, or D2 scripts—VPasCode instantly recognizes the DSL format and renders in real time.
• AI Code Error Fixing: Stuck on a syntax bug? Click “Fix by AI” to view transparent side-by-side diffs and automatically repair syntax errors.
• Multi-Language AI Translation: Effortlessly translate diagram labels and messages for international technical teams in seconds.
• High-Resolution Exporting: Download clean, scalable SVG vector graphics or high-res PNG images for technical documentation and slide decks.