Skip to content

ATM System

Problem Statement

Design an ATM system that allows users to perform banking operations like cash withdrawal, deposit, balance inquiry, and fund transfers. The system should authenticate users, communicate with the bank’s backend, handle cash dispensing, and maintain transaction logs.

Requirements

Functional Requirements

Authenticate users with card and PIN
Check account balance
Withdraw cash with denomination selection
Deposit cash and checks
Transfer funds between accounts
Print transaction receipts
Handle multiple account types (Savings, Checking)
Change PIN
Maintain transaction history
Handle insufficient funds and daily limits

Non-Functional Requirements

Secure PIN handling and encryption
Handle concurrent user sessions
Reliable cash dispensing mechanism
Transaction rollback on failures
Audit logging for all operations
Network resilience for bank communication

Simplified Class Diagram

Error generating PlantUML diagram: connect ECONNREFUSED 127.0.0.1:8080

@startuml

skinparam classBorderThickness 3
skinparam ArrowThickness 1
skinparam defaultFontSize 16
skinparam classAttributeFontSize 18
skinparam classFontSize 16

class ATMSystem {
  + authenticateUser()
  + checkBalance()
  + withdrawCash()
  + depositCash()
  + transferFunds()
}

class CardReader {
  + readCard()
  + ejectCard()
}

class CashDispenser {
  + dispenseCash()
  + checkCashAvailability()
}

class BankingService {
  + validateAccount()
  + processTransaction()
  + updateBalance()
}

class Transaction {
  + execute()
  + rollback()
}

class Account {
  + getBalance()
  + debit()
  + credit()
}

ATMSystem *-- CardReader
ATMSystem *-- CashDispenser
ATMSystem --> BankingService
ATMSystem ..> Transaction
BankingService --> Account
Transaction --> Account

@enduml

Simplified Overview

Error generating PlantUML diagram: connect ECONNREFUSED 127.0.0.1:8080

@startuml
skinparam componentStyle rectangle

package "ATM Service" {
    [ATMService] as Service
}

package "Hardware Interface" {
    interface "ICardReader" as Card
    interface "ICashDispenser" as Cash
    interface "IReceiptPrinter" as Receipt
    interface "IKeypad" as Keypad
    interface "IScreen" as Screen
}

package "State Management" {
    interface "IATMState" as State
    interface "IATMStateManager" as StateMgr
    [IdleState]
    [CardInsertedState]
    [AuthenticatedState]
    [TransactionState]
}

package "Banking" {
    interface "IBankingService" as BankingSvc
    interface "IAccount" as Account
}

package "Transaction" {
    interface "ITransactionHandler" as Handler
    [WithdrawalTransaction]
    [DepositTransaction]
    [BalanceInquiryTransaction]
}

[ATMDriver] --> Service : uses
Service *-- Card : composed of
Service *-- Cash : composed of
Service *-- Receipt : composed of
Service *-- Keypad : composed of
Service *-- Screen : composed of
Service *-- StateMgr : composed of
Service *-- BankingSvc : composed of
StateMgr *-- State : manages
State <|.. IdleState
State <|.. CardInsertedState
State <|.. AuthenticatedState
State <|.. TransactionState
BankingSvc o-- Account : manages
StateMgr ..> Handler : creates
Handler <|.. WithdrawalTransaction
Handler <|.. DepositTransaction
Handler <|.. BalanceInquiryTransaction

@enduml

Detailed Class Diagram

Error generating PlantUML diagram: connect ECONNREFUSED 127.0.0.1:8080

@startuml

enum AccountType {
    SAVINGS
    CHECKING
    CREDIT
}

enum TransactionType {
    WITHDRAWAL
    DEPOSIT
    TRANSFER
    BALANCE_INQUIRY
}

enum TransactionStatus {
    PENDING
    SUCCESS
    FAILED
    CANCELLED
}

enum CardStatus {
    ACTIVE
    BLOCKED
    EXPIRED
}

interface ICard {
    + getCardNumber(): String
    + validatePIN(pin: String): boolean
    + isValid(): boolean
    + getStatus(): CardStatus
}

class Card {
    - cardNumber: String
    - pinHash: String
    - expiryDate: Date
    - status: CardStatus
    - failedAttempts: int
    - pinValidator: IPinValidator
    + Card(cardNumber: String, pinHash: String, validator: IPinValidator)
    + validatePIN(pin: String): boolean
    + isValid(): boolean
}

interface IPinValidator {
    + validate(inputPin: String, storedHash: String): boolean
}

class PinValidator {
    + validate(inputPin: String, storedHash: String): boolean
}

interface IAccount {
    + getAccountNumber(): String
    + getBalance(): double
    + debit(amount: double): boolean
    + credit(amount: double): void
}

class Account {
    - accountNumber: String
    - type: AccountType
    - balance: double
    - withdrawalLimitChecker: IWithdrawalLimitChecker
    + Account(accountNumber: String, type: AccountType, checker: IWithdrawalLimitChecker)
    + getBalance(): double
    + debit(amount: double): boolean
    + credit(amount: double): void
}

interface IWithdrawalLimitChecker {
    + canWithdraw(account: IAccount, amount: double): boolean
    + recordWithdrawal(account: IAccount, amount: double): void
}

class DailyWithdrawalLimitChecker {
    - limits: Map<String, Double>
    + canWithdraw(account: IAccount, amount: double): boolean
    + recordWithdrawal(account: IAccount, amount: double): void
}

interface ICustomer {
    + getCustomerId(): String
    + getName(): String
    + getAccounts(): List<IAccount>
}

class Customer {
    - customerId: String
    - name: String
    - email: String
    - accounts: List<IAccount>
    - card: ICard
    + Customer(customerId: String, name: String)
    + getAccounts(): List<IAccount>
}

interface ITransaction {
    + getTransactionId(): String
    + getType(): TransactionType
    + execute(): boolean
    + rollback(): void
    + getStatus(): TransactionStatus
}

abstract class Transaction {
    - transactionId: String
    - type: TransactionType
    - status: TransactionStatus
    - timestamp: DateTime
    + Transaction(type: TransactionType)
    + {abstract} execute(): boolean
    + {abstract} rollback(): void
    + getStatus(): TransactionStatus
}

class WithdrawalTransaction {
    - account: IAccount
    - amount: double
    - cashDispenser: ICashDispenser
    + WithdrawalTransaction(account: IAccount, amount: double, dispenser: ICashDispenser)
    + execute(): boolean
    + rollback(): void
}

class DepositTransaction {
    - account: IAccount
    - amount: double
    + DepositTransaction(account: IAccount, amount: double)
    + execute(): boolean
    + rollback(): void
}

class TransferTransaction {
    - fromAccount: IAccount
    - toAccount: IAccount
    - amount: double
    + TransferTransaction(from: IAccount, to: IAccount, amount: double)
    + execute(): boolean
    + rollback(): void
}

interface ICashDispenser {
    + dispenseCash(amount: double): Map<Integer, Integer>
    + canDispense(amount: double): boolean
}

class CashDispenser {
    - denominations: Map<Integer, Integer>
    - denominationCalculator: IDenominationCalculator
    + CashDispenser(calculator: IDenominationCalculator)
    + dispenseCash(amount: double): Map<Integer, Integer>
    + canDispense(amount: double): boolean
}

interface IDenominationCalculator {
    + calculate(amount: double, available: Map<Integer, Integer>): Map<Integer, Integer>
}

class GreedyDenominationCalculator {
    + calculate(amount: double, available: Map<Integer, Integer>): Map<Integer, Integer>
}

interface ICardReader {
    + readCard(): ICard
    + ejectCard(): void
}

class CardReader {
    + readCard(): ICard
    + ejectCard(): void
}

interface IScreen {
    + displayMessage(message: String): void
    + displayMenu(options: List<String>): void
}

class Screen {
    + displayMessage(message: String): void
    + displayMenu(options: List<String>): void
}

interface IKeypad {
    + getInput(): String
    + getPIN(): String
}

class Keypad {
    + getInput(): String
    + getPIN(): String
}

interface IPrinter {
    + printReceipt(transaction: ITransaction): void
}

class ReceiptPrinter {
    + printReceipt(transaction: ITransaction): void
}

interface IBankService {
    + authenticateUser(cardNumber: String, pin: String): ICustomer
    + getAccount(accountNumber: String): IAccount
    + processTransaction(transaction: ITransaction): boolean
}

class BankAPIService {
    - apiUrl: String
    + authenticateUser(cardNumber: String, pin: String): ICustomer
    + getAccount(accountNumber: String): IAccount
    + processTransaction(transaction: ITransaction): boolean
}

interface IATMService {
    + start(): void
    + authenticateUser(): ICustomer
    + processTransaction(type: TransactionType): void
}

class ATMService {
    - atmId: String
    - cashDispenser: ICashDispenser
    - cardReader: ICardReader
    - screen: IScreen
    - keypad: IKeypad
    - printer: IPrinter
    - bankService: IBankService
    - stateManager: IATMStateManager
    + ATMService(atmId: String, dispenser: ICashDispenser, reader: ICardReader,
      screen: IScreen, keypad: IKeypad, printer: IPrinter, bank: IBankService,
      stateManager: IATMStateManager)
    + start(): void
    + authenticateUser(): ICustomer
    + processTransaction(type: TransactionType): void
}

interface IATMStateManager {
    + transitionTo(state: IATMState): void
    + getCurrentState(): IATMState
}

class ATMStateManager {
    - currentState: IATMState
    + transitionTo(state: IATMState): void
    + getCurrentState(): IATMState
}

interface IATMState {
    + insertCard(): void
    + ejectCard(): void
    + enterPIN(): void
    + selectOperation(): void
}

class IdleState {
    + insertCard(): void
    + ejectCard(): void
    + enterPIN(): void
    + selectOperation(): void
}

class AuthenticatedState {
    + insertCard(): void
    + ejectCard(): void
    + enterPIN(): void
    + selectOperation(): void
}

class ATMDriver {
    + {static} main(args: String[]): void
    - setupATM(): IATMService
    - demonstrateWithdrawal(): void
    - demonstrateDeposit(): void
}

ICard <|.. Card
Card --> CardStatus
Card --> IPinValidator
IPinValidator <|.. PinValidator

IAccount <|.. Account
Account --> AccountType
Account --> IWithdrawalLimitChecker
IWithdrawalLimitChecker <|.. DailyWithdrawalLimitChecker

ICustomer <|.. Customer
Customer --> ICard
Customer --> IAccount

ITransaction <|.. Transaction
Transaction --> TransactionType
Transaction --> TransactionStatus

Transaction <|-- WithdrawalTransaction
Transaction <|-- DepositTransaction
Transaction <|-- TransferTransaction

WithdrawalTransaction --> IAccount
WithdrawalTransaction --> ICashDispenser
DepositTransaction --> IAccount
TransferTransaction --> IAccount

ICashDispenser <|.. CashDispenser
CashDispenser --> IDenominationCalculator
IDenominationCalculator <|.. GreedyDenominationCalculator

ICardReader <|.. CardReader
IScreen <|.. Screen
IKeypad <|.. Keypad
IPrinter <|.. ReceiptPrinter

IBankService <|.. BankAPIService

IATMService <|.. ATMService
ATMService --> ICashDispenser
ATMService --> ICardReader
ATMService --> IScreen
ATMService --> IKeypad
ATMService --> IPrinter
ATMService --> IBankService
ATMService --> IATMStateManager

IATMStateManager <|.. ATMStateManager
ATMStateManager --> IATMState

IATMState <|.. IdleState
IATMState <|.. AuthenticatedState

ATMDriver ..> IATMService
ATMDriver ..> ICashDispenser
ATMDriver ..> IBankService

@enduml

Key Design Patterns

State Pattern: ATM states (Idle, CardInserted, Authenticated)
Strategy Pattern: Different transaction types
Singleton Pattern: ATM instance management
Factory Pattern: Create different transaction types
Proxy Pattern: BankService as proxy to backend

Design Pattern Diagrams

1. State Pattern - ATM State Management

Error generating PlantUML diagram: connect ECONNREFUSED 127.0.0.1:8080

@startuml

title State Pattern - ATM States

interface IATMState {
  + insertCard(ATMService, card): void
  + ejectCard(ATMService): void
  + enterPIN(ATMService, pin): void
  + selectTransaction(ATMService, type): void
  + executeTransaction(ATMService, details): void
}

class IdleState {
  + insertCard(ATMService, card): void
  + ejectCard(ATMService): void
}

class CardInsertedState {
  + enterPIN(ATMService, pin): void
  + ejectCard(ATMService): void
}

class AuthenticatedState {
  + selectTransaction(ATMService, type): void
  + ejectCard(ATMService): void
}

class TransactionState {
  + executeTransaction(ATMService, details): void
  + ejectCard(ATMService): void
}

class ATMService {
  - currentState: IATMState
  + setState(IATMState): void
  + insertCard(card): void
  + enterPIN(pin): void
  + withdraw(amount): void
}

IATMState <|.. IdleState
IATMState <|.. CardInsertedState
IATMState <|.. AuthenticatedState
IATMState <|.. TransactionState
ATMService *-- IATMState

note top of IATMState
  State transitions:
  Idle -> CardInserted -> Authenticated -> Transaction -> Idle
  Any state can return to Idle (eject card)
end note

note bottom of ATMService
  **Code Example:**

  ATMService atm = new ATMService();
  // State: IdleState

  atm.insertCard(card);
  // State transitions: Idle -> CardInserted
  // Screen shows: "Enter PIN"

  atm.enterPIN("1234");
  // State: CardInserted -> Authenticated
  // Screen shows: "Select Transaction"

  atm.selectTransaction(TransactionType.WITHDRAWAL);
  // State: Authenticated -> Transaction
  // Screen shows: "Enter amount"

  atm.withdraw(100);
  // Executes withdrawal
  // State: Transaction -> Idle
  // Card ejected

  // Invalid operations throw exceptions:
  atm.withdraw(100);  // IllegalStateException
  // "Cannot withdraw in Idle state"
end note

note right of IdleState
  **Allowed operations:**
  - insertCard() -> CardInserted

  **Blocked:**
  - enterPIN()
  - withdraw()

  class IdleState implements IATMState {
      public void insertCard(ATMService atm, Card card) {
          if (atm.validateCard(card)) {
              atm.setState(new CardInsertedState());
              atm.displayMessage("Enter PIN");
          }
      }

      public void withdraw(ATMService atm, double amount) {
          throw new IllegalStateException(
            "Insert card first"
          );
      }
  }
end note

@enduml

2. Strategy Pattern - Transaction Types

Error generating PlantUML diagram: connect ECONNREFUSED 127.0.0.1:8080

@startuml

title Strategy Pattern - Transaction Handling

interface ITransactionHandler {
  + execute(account, details): TransactionResult
  + validate(account, details): boolean
  + getTransactionType(): TransactionType
}

class WithdrawalTransaction {
  - cashDispenser: ICashDispenser
  + execute(account, details): TransactionResult
  + validate(account, details): boolean
}

class DepositTransaction {
  - cashAcceptor: ICashAcceptor
  + execute(account, details): TransactionResult
  + validate(account, details): boolean
}

class BalanceInquiryTransaction {
  + execute(account, details): TransactionResult
  + validate(account, details): boolean
}

class TransferTransaction {
  + execute(account, details): TransactionResult
  + validate(account, details): boolean
}

class ATMService {
  - transactionHandler: ITransactionHandler
  + setTransactionHandler(ITransactionHandler): void
  + processTransaction(details): TransactionResult
}

ITransactionHandler <|.. WithdrawalTransaction
ITransactionHandler <|.. DepositTransaction
ITransactionHandler <|.. BalanceInquiryTransaction
ITransactionHandler <|.. TransferTransaction
ATMService o-- ITransactionHandler

note bottom of WithdrawalTransaction
  **Validation:**
  - Sufficient balance
  - Daily limit not exceeded
  - Cash available in ATM

  **Execution:**
  - Debit account
  - Dispense cash
  - Print receipt
  - Update transaction log
end note

note bottom of ATMService
  **Code Example:**

  ATMService atm = new ATMService();

  // User selects withdrawal
  atm.setTransactionHandler(
    new WithdrawalTransaction(cashDispenser)
  );

  TransactionDetails details = new TransactionDetails();
  details.setAmount(100);
  details.setAccount(account);

  TransactionResult result = atm.processTransaction(details);

  if (result.isSuccess()) {
      cashDispenser.dispense(100);
      receiptPrinter.print(result.getReceipt());
  }

  // User selects balance inquiry
  atm.setTransactionHandler(
    new BalanceInquiryTransaction()
  );
  result = atm.processTransaction(details);
  screen.display("Balance: $" + result.getBalance());
end note

@enduml

3. Proxy Pattern - Banking Service

Error generating PlantUML diagram: connect ECONNREFUSED 127.0.0.1:8080

@startuml

title Proxy Pattern - Bank Service Proxy

interface IBankingService {
  + authenticateCard(cardNumber, pin): Account
  + getBalance(accountNumber): double
  + debit(accountNumber, amount): boolean
  + credit(accountNumber, amount): boolean
  + getTransactionHistory(accountNumber): List<Transaction>
}

class BankingServiceProxy {
  - realService: RemoteBankingService
  - cache: Map<String, Account>
  - rateLimiter: RateLimiter
  + authenticateCard(cardNumber, pin): Account
  + getBalance(accountNumber): double
  + debit(accountNumber, amount): boolean
  - checkCache(accountNumber): Account
  - logAccess(operation, accountNumber): void
}

class RemoteBankingService {
  - apiEndpoint: String
  - connection: Connection
  + authenticateCard(cardNumber, pin): Account
  + getBalance(accountNumber): double
  + debit(accountNumber, amount): boolean
}

class ATMService {
  - bankingService: IBankingService
  + ATMService(IBankingService)
  + processWithdrawal(amount): void
}

IBankingService <|.. BankingServiceProxy
IBankingService <|.. RemoteBankingService
BankingServiceProxy o-- RemoteBankingService
ATMService o-- IBankingService

note right of BankingServiceProxy
  **Proxy provides:**
  - Caching (reduce API calls)
  - Rate limiting
  - Access logging
  - Error handling
  - Connection pooling
  - Retry logic
end note

note bottom of BankingServiceProxy
  **Code Example:**

  class BankingServiceProxy implements IBankingService {
      private RemoteBankingService realService;
      private Map<String, Account> cache = new HashMap<>();

      public Account authenticateCard(String cardNumber, String pin) {
          // Rate limiting
          if (!rateLimiter.allowRequest()) {
              throw new TooManyRequestsException();
          }

          // Check cache
          String cacheKey = cardNumber + pin;
          if (cache.containsKey(cacheKey)) {
              return cache.get(cacheKey);
          }

          // Logging
          logAccess("authenticate", cardNumber);

          // Delegate to real service with retry
          Account account = null;
          for (int retry = 0; retry < 3; retry++) {
              try {
                  account = realService.authenticateCard(cardNumber, pin);
                  break;
              } catch (NetworkException e) {
                  Thread.sleep(1000 * (retry + 1));
              }
          }

          // Cache result
          if (account != null) {
              cache.put(cacheKey, account);
          }

          return account;
      }
  }

  // ATM uses proxy, unaware of complexity
  IBankingService bankService = new BankingServiceProxy(
    new RemoteBankingService("https://api.bank.com")
  );
  ATMService atm = new ATMService(bankService);
end note

@enduml

Code Snippets

Cash Withdrawal

1
public class ATM {
2
    public void withdrawCash(Account account, double amount) throws ATMException {
3
        // Validate amount
4
        if (amount <= 0 || amount % 10 != 0) {
5
            throw new ATMException("Invalid amount. Must be multiple of 10");
6
        }
7

8
        // Check ATM has sufficient cash
9
        if (!cashDispenser.canDispense(amount)) {
10
            throw new ATMException("Insufficient cash in ATM");
11
        }
12

13
        // Check account balance and limits
14
        if (!account.canWithdraw(amount)) {
15
            throw new ATMException("Insufficient funds or daily limit exceeded");
16
        }
17

18
        // Create transaction
19
        WithdrawalTransaction transaction = new WithdrawalTransaction(account, amount);
20

21
        try {
22
            // Process with bank
23
            if (bankService.processTransaction(transaction)) {
24
                // Dispense cash
25
                Map<Integer, Integer> denominations = cashDispenser.dispenseCash(amount);
26
                cashSlot.dispenseCash(denominations);
27

28
                // Update account
29
                account.debit(amount);
30
                transaction.setStatus(TransactionStatus.SUCCESS);
31

32
                // Print receipt
33
                printer.printReceipt(transaction);
34

35
                currentSession.addTransaction(transaction);
36
                screen.displayMessage("Please collect your cash");
37
            } else {
38
                throw new ATMException("Transaction failed");
39
            }
40
        } catch (Exception e) {
41
            transaction.rollback();
42
            transaction.setStatus(TransactionStatus.FAILED);
43
            throw new ATMException("Transaction failed: " + e.getMessage());
44
        }
45
    }
46
}

Cash Dispenser Logic

1
public class CashDispenser {
2
    private Map<Integer, Integer> denominations; // denomination -> count
3

4
    public Map<Integer, Integer> dispenseCash(double amount) throws ATMException {
5
        Map<Integer, Integer> result = calculateDenominations(amount);
6

7
        if (result == null) {
8
            throw new ATMException("Cannot dispense exact amount");
9
        }
10

11
        // Deduct from inventory
12
        for (Map.Entry<Integer, Integer> entry : result.entrySet()) {
13
            int denom = entry.getKey();
14
            int count = entry.getValue();
15
            denominations.put(denom, denominations.get(denom) - count);
16
        }
17

18
        totalCash -= amount;
19
        return result;
20
    }
21

22
    private Map<Integer, Integer> calculateDenominations(double amount) {
23
        Map<Integer, Integer> result = new HashMap<>();
24
        int remaining = (int) amount;
25

26
        // Try to dispense using available denominations (100, 50, 20, 10)
27
        int[] denoms = {100, 50, 20, 10};
28

29
        for (int denom : denoms) {
30
            if (remaining >= denom && denominations.get(denom) > 0) {
31
                int count = Math.min(remaining / denom, denominations.get(denom));
32
                if (count > 0) {
33
                    result.put(denom, count);
34
                    remaining -= denom * count;
35
                }
36
            }
37
        }
38

39
        return remaining == 0 ? result : null;
40
    }
41
}

User Authentication

1
public class ATM {
2
    public Customer authenticateUser() throws ATMException {
3
        screen.displayMessage("Please insert your card");
4
        Card card = cardReader.readCard();
5

6
        if (card == null) {
7
            throw new ATMException("Card read error");
8
        }
9

10
        if (card.isExpired()) {
11
            cardReader.ejectCard();
12
            throw new ATMException("Card has expired");
13
        }
14

15
        if (card.isBlocked()) {
16
            cardReader.ejectCard();
17
            throw new ATMException("Card is blocked");
18
        }
19

20
        // Get PIN
21
        screen.displayMessage("Please enter your PIN");
22
        String pin = keypad.getPIN();
23

24
        if (!card.validatePIN(pin)) {
25
            card.incrementFailedAttempts();
26

27
            if (card.getFailedAttempts() >= 3) {
28
                card.setStatus(CardStatus.BLOCKED);
29
                cardReader.ejectCard();
30
                throw new ATMException("Card blocked due to multiple failed attempts");
31
            }
32

33
            cardReader.ejectCard();
34
            throw new ATMException("Invalid PIN");
35
        }
36

37
        // Authenticate with bank
38
        Customer customer = bankService.authenticateUser(card.getCardNumber(), pin);
39

40
        if (customer == null) {
41
            cardReader.ejectCard();
42
            throw new ATMException("Authentication failed");
43
        }
44

45
        card.resetFailedAttempts();
46
        currentSession = new ATMSession(customer);
47

48
        return customer;
49
    }
50
}

Fund Transfer

1
public class TransferTransaction extends Transaction {
2
    private Account fromAccount;
3
    private Account toAccount;
4

5
    @Override
6
    public boolean execute() {
7
        try {
8
            // Validate accounts
9
            if (fromAccount == null || toAccount == null) {
10
                status = TransactionStatus.FAILED;
11
                return false;
12
            }
13

14
            // Check balance
15
            if (!fromAccount.canWithdraw(amount)) {
16
                status = TransactionStatus.FAILED;
17
                description = "Insufficient funds";
18
                return false;
19
            }
20

21
            // Debit from source
22
            if (!fromAccount.debit(amount)) {
23
                status = TransactionStatus.FAILED;
24
                return false;
25
            }
26

27
            // Credit to destination
28
            toAccount.credit(amount);
29

30
            status = TransactionStatus.SUCCESS;
31
            description = "Transfer successful";
32
            return true;
33

34
        } catch (Exception e) {
35
            status = TransactionStatus.FAILED;
36
            rollback();
37
            return false;
38
        }
39
    }
40

41
    @Override
42
    public void rollback() {
43
        if (fromAccount != null) {
44
            fromAccount.credit(amount); // Refund
45
        }
46
    }
47
}

Extension Points

Add biometric authentication (fingerprint, face recognition)
Implement cardless withdrawal using mobile QR codes
Add multi-currency support
Implement check imaging for deposits
Add bill payment functionality
Support mini-statement printing
Implement dynamic cash optimization
Add remote monitoring and maintenance
Support contactless card reading (NFC)
Implement fraud detection mechanisms