┌─────────────────────────────────────────────────────────────────────────────┐
│                    RPA MATURITY MODEL                                      │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  Level 1           Level 2           Level 3           Level 4             │
│  ┌─────────┐      ┌─────────┐      ┌─────────┐      ┌─────────┐          │
│  │ Desktop│        │ Process│        │      │        │ Intelligent│        │
│  │ Automation│ ──→ │ Automation│ ──→ │ Enterprise│ ──→ │ Automation │      │
│  │ (Basic) │      │ (Standard)│    │ (Scaled)│      │ (AI-Powered)│      │
│  └─────────┘      └─────────┘      └─────────┘      └─────────┘          │
│                                                                             │
│  • Single tasks   • Multi-step     • Cross-system   • AI/ML                │
│  • Rule-based     • Rule-based     • Orchestration  • Cognitive            │
│  • Simple         • Reusable       • Governance     • Autonomous           │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    RPA ARCHITECTURE                                        │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    USER INTERFACE                                   │   │
│  │  (Browser, Desktop Applications, Email, Chat)                       │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    RPA BOT                                           │   │
│  │  (UiPath, Automation Anywhere, Blue Prism)                          │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    ORCHESTRATOR                                     │   │
│  │  (Bot management, scheduling, monitoring, analytics)                │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    BACKEND SYSTEMS                                  │   │
│  │  (Core Banking, CRM, ERP, Data Warehouses)                         │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    RPA IMPLEMENTATION METHODOLOGY                         │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    1. ASSESSMENT                                    │   │
│  │  Identify processes, assess suitability, define success metrics.     │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    2. DESIGN                                        │   │
│  │  Create detailed process maps, design automation flow.              │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    3. DEVELOPMENT                                   │   │
│  │  Build the automation using RPA tools.                              │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    4. TESTING                                       │   │
│  │  Test the automation in a controlled environment.                    │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    5. DEPLOYMENT                                    │   │
│  │  Deploy to production, monitor, and manage.                        │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    6. MONITORING & OPTIMISATION                     │   │
│  │  Monitor performance, collect feedback, and optimise.               │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# ===================================================================
# MODULE 3, LESSON 2: ROBOTIC PROCESS AUTOMATION (RPA) IN BANKING
# ===================================================================

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from datetime import datetime, timedelta
import time
import warnings
warnings.filterwarnings('ignore')

print("="*70)
print("ROBOTIC PROCESS AUTOMATION (RPA) IN BANKING")
print("="*70)

# ----------------------------------------------------------------
# PART A: RPA PROCESS SELECTION MATRIX
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: RPA Process Selection Matrix")
print("-"*60)

# Define processes and selection criteria
processes = ['Data Entry', 'Payment Processing', 'Report Generation', 'Customer Onboarding',
             'Loan Processing', 'Reconciliation', 'Fraud Monitoring', 'Compliance Reporting',
             'Invoice Processing', 'Customer Service Updates']

criteria = {
    'Rule-Based (1-5)': [5, 4, 4, 4, 4, 5, 3, 4, 5, 3],
    'Repetitive (1-5)': [5, 5, 4, 4, 4, 5, 4, 4, 5, 4],
    'High Volume (1-5)': [5, 5, 4, 3, 3, 5, 5, 3, 4, 4],
    'Structured Data (1-5)': [5, 5, 5, 4, 4, 5, 4, 5, 5, 4],
    'Low Complexity (1-5)': [5, 4, 4, 3, 3, 4, 2, 4, 5, 3],
    'ROI Potential (1-5)': [4, 5, 4, 5, 5, 4, 5, 4, 4, 4]
}

selection_df = pd.DataFrame(criteria, index=processes)
selection_df['Total Score'] = selection_df.sum(axis=1)
selection_df = selection_df.sort_values('Total Score', ascending=False)

print("RPA Process Selection Matrix:")
print(selection_df.to_string())

# ----------------------------------------------------------------
# PART B: RPA IMPACT ANALYSIS
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: RPA Impact Analysis")
print("-"*60)

# Define impact metrics for top RPA processes
processes_selected = ['Data Entry', 'Payment Processing', 'Reconciliation', 'Customer Onboarding', 'Loan Processing']

baseline_data = {
    'Process': processes_selected,
    'Manual Time (min)': [15, 10, 20, 30, 45],
    'Manual Cost ($)': [3.50, 2.50, 5.00, 7.50, 12.00],
    'Error Rate (%)': [2.5, 1.5, 3.0, 2.0, 1.8],
    'Processing Volume (daily)': [1000, 5000, 2000, 500, 300]
}

impact_df = pd.DataFrame(baseline_data)

# RPA impact (simulated)
impact_df['RPA Time (min)'] = impact_df['Manual Time (min)'] * 0.10  # 90% reduction
impact_df['RPA Cost ($)'] = impact_df['Manual Cost ($)'] * 0.15     # 85% reduction
impact_df['RPA Error Rate (%)'] = impact_df['Error Rate (%)'] * 0.10 # 90% reduction
impact_df['Time Saved (min)'] = impact_df['Manual Time (min)'] - impact_df['RPA Time (min)']
impact_df['Cost Saved ($)'] = impact_df['Manual Cost ($)'] - impact_df['RPA Cost ($)']
impact_df['Annual Savings ($)'] = impact_df['Cost Saved ($)'] * impact_df['Processing Volume (daily)'] * 250

print("RPA Impact Analysis:")
print(impact_df.round(2).to_string(index=False))

# Visualise
fig, axes = plt.subplots(2, 2, figsize=(14, 10))

# Time Reduction
ax = axes[0, 0]
x = np.arange(len(processes_selected))
width = 0.35
ax.bar(x - width/2, impact_df['Manual Time (min)'], width, label='Manual', color='red', alpha=0.7)
ax.bar(x + width/2, impact_df['RPA Time (min)'], width, label='RPA', color='green', alpha=0.7)
ax.set_xlabel('Process')
ax.set_ylabel('Time (minutes)')
ax.set_title('Time Reduction with RPA')
ax.set_xticks(x)
ax.set_xticklabels(processes_selected, rotation=45, ha='right')
ax.legend()
ax.grid(True, alpha=0.3)

# Cost Reduction
ax = axes[0, 1]
ax.bar(x - width/2, impact_df['Manual Cost ($)'], width, label='Manual', color='red', alpha=0.7)
ax.bar(x + width/2, impact_df['RPA Cost ($)'], width, label='RPA', color='green', alpha=0.7)
ax.set_xlabel('Process')
ax.set_ylabel('Cost ($)')
ax.set_title('Cost Reduction with RPA')
ax.set_xticks(x)
ax.set_xticklabels(processes_selected, rotation=45, ha='right')
ax.legend()
ax.grid(True, alpha=0.3)

# Error Rate Reduction
ax = axes[1, 0]
ax.bar(x - width/2, impact_df['Error Rate (%)'], width, label='Manual', color='red', alpha=0.7)
ax.bar(x + width/2, impact_df['RPA Error Rate (%)'], width, label='RPA', color='green', alpha=0.7)
ax.set_xlabel('Process')
ax.set_ylabel('Error Rate (%)')
ax.set_title('Error Rate Reduction with RPA')
ax.set_xticks(x)
ax.set_xticklabels(processes_selected, rotation=45, ha='right')
ax.legend()
ax.grid(True, alpha=0.3)

# Annual Savings
ax = axes[1, 1]
bars = ax.barh(processes_selected, impact_df['Annual Savings ($)'] / 1000, color='teal', alpha=0.7)
ax.set_xlabel('Annual Savings ($000)')
ax.set_title('Annual Savings from RPA')
for bar, savings in zip(bars, impact_df['Annual Savings ($)'] / 1000):
    ax.text(bar.get_width() + 1, bar.get_y() + bar.get_height()/2, 
            f'${savings:.0f}K', ha='left', va='center')
ax.grid(True, alpha=0.3, axis='x')

plt.tight_layout()
plt.savefig('rpa_impact.png', dpi=300, bbox_inches='tight')
plt.show()
print("RPA impact visualisation saved as 'rpa_impact.png'")

# ----------------------------------------------------------------
# PART C: RPA BOT TYPES AND CHARACTERISTICS
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: RPA Bot Types and Characteristics")
print("-"*60)

bot_types = pd.DataFrame({
    'Bot Type': ['Attended', 'Unattended', 'Hybrid', 'Cloud'],
    'Description': [
        'Runs on user's desktop, triggered by user.',
        'Runs on server, scheduled or event-triggered.',
        'Combination of attended and unattended.',
        'Cloud-based, scalable, accessible anywhere.'
    ],
    'Use Case': [
        'Data entry assistance, help desk.',
        'Batch processing, reconciliation.',
        'Complex workflows with human exception handling.',
        'Distributed teams, rapid scaling.'
    ],
    'Pros': [
        'User-friendly, easy to supervise.',
        '24/7 operation, high volume.',
        'Flexible, comprehensive.',
        'Scalable, cost-effective.'
    ],
    'Cons': [
        'Requires user interaction.',
        'Less oversight, error handling needed.',
        'Complex to implement.',
        'Internet dependency, security concerns.'
    ]
})

print("RPA Bot Types:")
print(bot_types.to_string(index=False))

# ----------------------------------------------------------------
# PART D: RPA IMPLEMENTATION ROADMAP
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART D: RPA Implementation Roadmap")
print("-"*60)

implementation_roadmap = {
    "Phase 1 (0-3 months) – Pilot": {
        "Focus": "Implement RPA for 1-2 simple, high-ROI processes.",
        "Activities": [
            "Identify and select pilot processes.",
            "Set up RPA infrastructure.",
            "Develop and deploy initial bots.",
            "Measure and validate results."
        ],
        "Success Metrics": ["Processing time reduced by 50%", "Manual effort reduced by 30%"]
    },
    "Phase 2 (3-6 months) – Scaling": {
        "Focus": "Expand to 5-10 processes across the organisation.",
        "Activities": [
            "Scale RPA to more processes.",
            "Establish RPA Centre of Excellence (CoE).",
            "Implement governance and standards.",
            "Train additional team members."
        ],
        "Success Metrics": ["Processes automated: 10+", "FTE savings: 20+"]
    },
    "Phase 3 (6-12 months) – Enterprise": {
        "Focus": "Large-scale deployment across functions.",
        "Activities": [
            "Implement enterprise-wide RPA.",
            "Integrate with AI/ML capabilities.",
            "Establish self-service automation.",
            "Optimise and enhance existing bots."
        ],
        "Success Metrics": ["Automation coverage > 50%", "Operational costs reduced by 30%"]
    },
    "Phase 4 (12+ months) – Intelligent": {
        "Focus": "Combine RPA with AI for cognitive automation.",
        "Activities": [
            "Implement AI-powered process automation.",
            "Enable predictive and prescriptive analytics.",
            "Develop autonomous operations.",
            "Build a culture of continuous automation."
        ],
        "Success Metrics": ["STP rate > 90%", "End-to-end automation"]
    }
}

for phase, details in implementation_roadmap.items():
    print(f"\n{phase}:")
    print(f"  Focus: {details['Focus']}")
    print("  Activities:")
    for activity in details['Activities']:
        print(f"    • {activity}")
    print("  Success Metrics:")
    for metric in details['Success Metrics']:
        print(f"    • {metric}")

# ----------------------------------------------------------------
# PART E: RPA PERFORMANCE METRICS
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART E: RPA Performance Metrics")
print("-"*60)

rpa_metrics = pd.DataFrame({
    'Metric': [
        'Automation Rate',
        'Bot Uptime',
        'Transaction Throughput',
        'Error Rate',
        'Resolution Time',
        'ROI',
        'Cost Savings',
        'FTE Equivalent'
    ],
    'Current Value': [
        '42%',
        '99.2%',
        '18.5K/day',
        '0.3%',
        '2.1 min',
        '320%',
        '$1.2M/year',
        '24'
    ],
    'Target Value': [
        '> 80%',
        '> 99.5%',
        '> 25K/day',
        '< 0.1%',
        '< 1 min',
        '> 500%',
        '$3M/year',
        '50'
    ],
    'Status': ['🟡', '🟡', '🟡', '🟡', '🟡', '🟡', '🟡', '🟡']
})

print("RPA Performance Metrics:")
print(rpa_metrics.to_string(index=False))

# ----------------------------------------------------------------
# PART F: RPA CHALLENGES AND SOLUTIONS
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART F: RPA Challenges and Solutions")
print("-"*60)

challenges = pd.DataFrame({
    'Challenge': [
        'Process Selection',
        'Change Management',
        'Bot Maintenance',
        'Security',
        'Integration',
        'Governance',
        'Skill Gap',
        'Scalability'
    ],
    'Impact': ['High', 'High', 'Medium', 'Critical', 'High', 'High', 'High', 'Medium'],
    'Solution': [
        'Use structured selection criteria, pilot first.',
        'Stakeholder engagement, training, communication.',
        'Regular monitoring, version control, updates.',
        'Role-based access, encryption, audit trails.',
        'API-first architecture, middleware solutions.',
        'Centre of Excellence, governance framework.',
        'Training, hiring, external partners.',
        'Cloud-based RPA, orchestration tools.'
    ]
})

print("RPA Challenges and Solutions:")
print(challenges.to_string(index=False))

# ----------------------------------------------------------------
# PART G: SUMMARY AND RECOMMENDATIONS
# ----------------------------------------------------------------

print("\n" + "="*70)
print("PART G: Summary and Recommendations")
print("="*70)

print("""
Robotic Process Automation (RPA) – Key Takeaways:

1. RPA automates repetitive, rule-based tasks in banking operations.
2. Key use cases: customer onboarding, payment processing, reconciliation, reporting.
3. RPA architecture includes bots, orchestrators, and integration with backend systems.
4. Benefits: reduced costs, faster processing, fewer errors, improved CX.
5. Implementation: assess → design → develop → test → deploy → monitor.
6. Best practices: start small, choose the right process, engage stakeholders, test thoroughly.
7. Challenges: process selection, change management, maintenance, security, governance.

Recommendations:
  - Start with a pilot process.
  - Build a Centre of Excellence (CoE).
  - Establish governance and standards.
  - Monitor and measure RPA performance.
  - Combine RPA with AI for intelligent automation.
  - Foster a culture of continuous improvement.
""")

print("="*70)
print("END OF LESSON 2 – MODULE 3")
print("="*70)