banking-expert

Banking Expert

Expert guidance for banking systems, core banking platforms, regulatory compliance, and banking technology.

Core Concepts

Banking Systems

Core banking systems (CBS)
Account management
Transaction processing
Payment systems (ACH, SWIFT, SEPA)
Loan management
Risk management systems

Regulations

Basel III/IV capital requirements
Know Your Customer (KYC)
Anti-Money Laundering (AML)
GDPR for banking
PSD2 (Payment Services Directive)
Dodd-Frank Act

Key Technologies

Real-time payment processing
Mobile banking
Open banking APIs
Digital wallets
Blockchain in banking
AI for fraud detection

Account Management

from decimal import Decimal from datetime import datetime from enum import Enum

class AccountType(Enum): CHECKING = "checking" SAVINGS = "savings" CREDIT = "credit" LOAN = "loan"

class Account: def init(self, account_number: str, account_type: AccountType, customer_id: str, balance: Decimal = Decimal('0')): self.account_number = account_number self.type = account_type self.customer_id = customer_id self.balance = balance self.status = "ACTIVE" self.created_at = datetime.now()

def deposit(self, amount: Decimal) -> dict:
    """Deposit funds with validation"""
    if amount &#x3C;= 0:
        raise ValueError("Amount must be positive")

    self.balance += amount

    return {
        "transaction_id": self.generate_transaction_id(),
        "type": "DEPOSIT",
        "amount": amount,
        "balance": self.balance,
        "timestamp": datetime.now()
    }

def withdraw(self, amount: Decimal) -> dict:
    """Withdraw funds with balance check"""
    if amount &#x3C;= 0:
        raise ValueError("Amount must be positive")

    if self.balance &#x3C; amount:
        raise ValueError("Insufficient funds")

    self.balance -= amount

    return {
        "transaction_id": self.generate_transaction_id(),
        "type": "WITHDRAWAL",
        "amount": amount,
        "balance": self.balance,
        "timestamp": datetime.now()
    }

def transfer(self, to_account: 'Account', amount: Decimal) -> dict:
    """Transfer funds between accounts"""
    # Withdraw from source
    withdrawal = self.withdraw(amount)

    try:
        # Deposit to destination
        deposit = to_account.deposit(amount)

        return {
            "transaction_id": self.generate_transaction_id(),
            "type": "TRANSFER",
            "from_account": self.account_number,
            "to_account": to_account.account_number,
            "amount": amount,
            "timestamp": datetime.now()
        }
    except Exception as e:
        # Rollback on failure
        self.deposit(amount)
        raise e

KYC/AML Compliance

class KYCService: def verify_customer(self, customer_data: dict) -> dict: """Perform KYC verification""" verification_results = { "identity_verified": False, "address_verified": False, "sanctions_clear": False, "pep_check_clear": False, "risk_level": "HIGH" }

    # Identity verification
    verification_results["identity_verified"] = self.verify_identity(
        customer_data["id_document"]
    )

    # Address verification
    verification_results["address_verified"] = self.verify_address(
        customer_data["proof_of_address"]
    )

    # Sanctions screening
    verification_results["sanctions_clear"] = self.screen_sanctions(
        customer_data["name"],
        customer_data["date_of_birth"]
    )

    # PEP (Politically Exposed Person) check
    verification_results["pep_check_clear"] = self.check_pep(
        customer_data["name"]
    )

    # Calculate risk level
    verification_results["risk_level"] = self.calculate_risk_level(
        verification_results
    )

    return verification_results

class AMLMonitoring: def monitor_transaction(self, transaction: dict) -> dict: """Monitor transaction for suspicious activity""" flags = []

    # Large transaction
    if transaction["amount"] > 10000:
        flags.append("LARGE_TRANSACTION")

    # Rapid succession of transactions
    if self.check_velocity(transaction["account_id"]):
        flags.append("HIGH_VELOCITY")

    # Unusual pattern
    if self.check_pattern(transaction):
        flags.append("UNUSUAL_PATTERN")

    # International transfer to high-risk country
    if transaction.get("international") and \
       self.is_high_risk_country(transaction.get("destination")):
        flags.append("HIGH_RISK_COUNTRY")

    if flags:
        self.file_suspicious_activity_report(transaction, flags)

    return {
        "flagged": len(flags) > 0,
        "flags": flags,
        "risk_score": self.calculate_aml_risk_score(flags)
    }

Payment Processing

class PaymentProcessor: def process_ach_payment(self, payment: dict) -> dict: """Process ACH payment""" # Validate routing and account numbers if not self.validate_routing_number(payment["routing_number"]): raise ValueError("Invalid routing number")

    # Create ACH file
    ach_batch = self.create_ach_batch([payment])

    # Submit to ACH network
    submission_result = self.submit_to_ach_network(ach_batch)

    return {
        "payment_id": payment["id"],
        "status": "PENDING",
        "expected_settlement": self.calculate_settlement_date(),
        "trace_number": submission_result["trace_number"]
    }

def process_wire_transfer(self, wire: dict) -> dict:
    """Process SWIFT wire transfer"""
    # Generate SWIFT message
    swift_message = self.create_swift_mt103(wire)

    # Send via SWIFT network
    result = self.send_swift_message(swift_message)

    return {
        "wire_id": wire["id"],
        "status": "SENT",
        "swift_reference": result["reference"],
        "fee": self.calculate_wire_fee(wire["amount"])
    }

Interest Calculation

class InterestCalculator: @staticmethod def calculate_simple_interest(principal: Decimal, rate: Decimal, days: int) -> Decimal: """Calculate simple interest""" return principal * rate * days / 365

@staticmethod
def calculate_compound_interest(principal: Decimal, annual_rate: Decimal,
                               years: int, compounds_per_year: int = 12) -> Decimal:
    """Calculate compound interest"""
    rate_per_period = annual_rate / compounds_per_year
    num_periods = years * compounds_per_year

    return principal * ((1 + rate_per_period) ** num_periods - 1)

@staticmethod
def calculate_loan_payment(principal: Decimal, annual_rate: Decimal,
                          months: int) -> Decimal:
    """Calculate monthly loan payment"""
    monthly_rate = annual_rate / 12

    payment = principal * (monthly_rate * (1 + monthly_rate) ** months) / \
              ((1 + monthly_rate) ** months - 1)

    return payment.quantize(Decimal('0.01'))

Best Practices

Implement two-factor authentication
Use encryption for sensitive data (at rest and in transit)
Maintain complete audit trails
Implement real-time fraud detection
Ensure ACID compliance for transactions
Regular security audits and penetration testing
Implement rate limiting on APIs
Use tokenization for sensitive data
Maintain disaster recovery and business continuity plans
Regular regulatory compliance reviews

Anti-Patterns

❌ Storing sensitive data unencrypted ❌ No transaction logging/audit trail ❌ Synchronous payment processing ❌ Ignoring regulatory compliance ❌ No fraud detection mechanisms ❌ Using floats for money calculations ❌ No backup and recovery procedures

Resources

Basel Committee: https://www.bis.org/bcbs/
SWIFT Standards: https://www.swift.com/standards
PSD2: https://ec.europa.eu/info/law/payment-services-psd-2
FFIEC: https://www.ffiec.gov/

banking-expert

Safety Notice

Copy this and send it to your AI assistant to learn

Source Transparency

Related Skills

finance-expert

trading-expert

dart-expert

postgresql-expert