Introduction to RPA: Concepts, Benefits, and Industry Applications

Detailed Description

Robotic Process Automation (RPA) represents a transformative technology that enables organizations to automate repetitive, rule-based business processes through software robots or "bots." These digital workers interact with applications and systems just as humans do—clicking buttons, entering data, navigating interfaces, extracting information, and performing calculations—but with significantly greater speed, accuracy, and consistency. RPA has evolved dramatically from its origins in screen scraping and macro recording technologies of the 1990s to today's sophisticated intelligent automation platforms that incorporate artificial intelligence, machine learning, and cognitive capabilities. This evolution has positioned RPA as a cornerstone technology in digital transformation initiatives across virtually every industry sector.

The importance of RPA in modern business operations cannot be overstated. Organizations face mounting pressure to reduce operational costs, improve efficiency, enhance customer experience, and enable their human workforce to focus on higher-value activities. RPA addresses these challenges by automating time-consuming manual tasks that drain productivity and introduce human error. In financial services, RPA bots process loan applications in minutes rather than days. In healthcare, they manage patient records and insurance claims with unprecedented accuracy. In retail, they orchestrate complex supply chain operations and customer service interactions. The technology delivers measurable ROI typically within 6-12 months, with some implementations showing productivity improvements of 40-70% and accuracy rates exceeding 99%. Beyond cost savings, RPA enables 24/7 operations, improves compliance through consistent process execution, and generates valuable process insights through automation analytics.

Understanding RPA requires familiarity with several core concepts and principles. Software robots are configurable automation programs that mimic human interactions with digital systems. Attended bots work alongside humans, triggered by user actions and typically handling front-office processes like customer service interactions. Unattended bots operate independently without human intervention, usually scheduled to run back-office processes like batch processing or data reconciliation. Hybrid bots combine both modes, adapting to workflow requirements. The architecture typically includes a Control Room (centralized management console), Bot Creator (development environment), and Bot Runners (execution environments). Modern RPA platforms integrate with Cognitive Automation capabilities including Natural Language Processing (NLP), Optical Character Recognition (OCR), Machine Learning (ML), and Computer Vision, enabling bots to handle unstructured data and make intelligent decisions.

Common RPA use cases span multiple business functions and industries. In Finance & Accounting, bots automate invoice processing, accounts payable/receivable, financial reconciliation, and regulatory reporting. Human Resources departments leverage RPA for employee onboarding, payroll processing, time and attendance tracking, and benefits administration. Supply Chain & Procurement operations use RPA for purchase order processing, inventory management, vendor management, and order fulfillment. Customer Service implementations include automated ticket routing, data entry, status updates, and response generation. IT Operations benefit from automated system monitoring, password resets, software installations, and data backups. Industry-specific applications include claims processing in insurance, loan origination in banking, patient record management in healthcare, and price monitoring in retail.

By completing this lesson, students will master the foundational concepts necessary for successful RPA implementation. You will understand the historical context and technological evolution of RPA, enabling you to appreciate current capabilities and future trends. You will be able to distinguish between different types of automation and identify appropriate use cases for attended versus unattended bots. Through real-world case studies from banking, insurance, healthcare, and retail sectors, you will learn to recognize patterns of successful implementation and avoid common pitfalls. You will develop the ability to articulate RPA's value proposition to stakeholders, estimate implementation timelines and ROI, and position RPA within broader digital transformation and AI strategies. Most importantly, you will acquire the conceptual foundation needed to design, develop, and deploy production-grade RPA solutions in the subsequent modules of this course.

Practical Examples

Example 1: Basic Bot Structure - Invoice Data Extraction

This example demonstrates a fundamental RPA bot structure using UiPath syntax that extracts invoice data from a CSV file and populates it into an accounting system. This represents a common use case in accounts payable automation.


' Main Bot Workflow - Invoice Processing Automation
' Purpose: Extract invoice data from CSV and input into ERP system
' Type: Unattended Bot
' Estimated Runtime: 2-3 minutes per invoice

' Initialize variables and logging
Dim invoiceFilePath As String = "C:\Invoices\pending_invoices.csv"
Dim processedCount As Integer = 0
Dim errorCount As Integer = 0
Dim startTime As DateTime = DateTime.Now

Try
    ' Log bot start
    Log Message("INFO", "Invoice processing bot started at " + startTime.ToString())
    
    ' Read invoice data from CSV file
    Dim invoiceTable As DataTable = Read CSV(invoiceFilePath)
    Log Message("INFO", "Loaded " + invoiceTable.Rows.Count.ToString() + " invoices for processing")
    
    ' Open ERP application
    Open Application("ERPSystem.exe")
    Wait For Element("LoginScreen", 30)
    
    ' Login to ERP system using credentials from Credential Manager
    Dim username As String = Get Credential("ERP_User", "Username")
    Dim password As String = Get Credential("ERP_User", "Password")
    Type Into(username, "UsernameField")
    Type Into(password, "PasswordField", SimulateType:=True, EncryptedInput:=True)
    Click("LoginButton")
    Wait For Element("MainDashboard", 30)
    
    ' Process each invoice in the data table
    For Each invoiceRow As DataRow In invoiceTable.Rows
        Try
            ' Extract invoice fields
            Dim invoiceNumber As String = invoiceRow("InvoiceNumber").ToString()
            Dim vendorName As String = invoiceRow("VendorName").ToString()
            Dim invoiceDate As String = invoiceRow("InvoiceDate").ToString()
            Dim amount As Decimal = Convert.ToDecimal(invoiceRow("Amount"))
            Dim description As String = invoiceRow("Description").ToString()
            
            Log Message("INFO", "Processing invoice: " + invoiceNumber)
            
            ' Navigate to invoice entry screen
            Click("InvoicesMenu")
            Click("NewInvoiceButton")
            Wait For Element("InvoiceEntryForm", 10)
            
            ' Enter invoice data with validation
            Type Into(invoiceNumber, "InvoiceNumberField")
            Type Into(vendorName, "VendorNameField")
            Type Into(invoiceDate, "InvoiceDateField")
            Type Into(amount.ToString("F2"), "AmountField")
            Type Into(description, "DescriptionField")
            
            ' Submit invoice
            Click("SubmitButton")
            
            ' Wait for confirmation and verify success
            Wait For Element("SuccessMessage", 10)
            Dim confirmationNumber As String = Get Text("ConfirmationNumberField")
            
            ' Update processing count and log success
            processedCount = processedCount + 1
            Log Message("SUCCESS", "Invoice " + invoiceNumber + " processed. Confirmation: " + confirmationNumber)
            
            ' Update status in CSV (mark as processed)
            invoiceRow("Status") = "Processed"
            invoiceRow("ProcessedDate") = DateTime.Now.ToString()
            invoiceRow("ConfirmationNumber") = confirmationNumber
            
        Catch ex As Exception
            ' Handle individual invoice errors
            errorCount = errorCount + 1
            Log Message("ERROR", "Failed to process invoice: " + invoiceRow("InvoiceNumber").ToString() + " - " + ex.Message)
            invoiceRow("Status") = "Error"
            invoiceRow("ErrorMessage") = ex.Message
            
            ' Take screenshot for debugging
            Take Screenshot("Error_" + invoiceRow("InvoiceNumber").ToString() + "_" + DateTime.Now.ToString("yyyyMMddHHmmss") + ".png")
            
            ' Navigate back to main screen for next invoice
            Click("CancelButton")
        End Try
    Next
    
    ' Save updated CSV with processing results
    Write CSV(invoiceTable, "C:\Invoices\processed_invoices_" + DateTime.Now.ToString("yyyyMMdd") + ".csv")
    
    ' Close application
    Close Application("ERPSystem.exe")
    
    ' Calculate and log summary statistics
    Dim endTime As DateTime = DateTime.Now
    Dim duration As TimeSpan = endTime.Subtract(startTime)
    Log Message("INFO", "Bot completed. Processed: " + processedCount.ToString() + " | Errors: " + errorCount.ToString() + " | Duration: " + duration.TotalMinutes.ToString("F2") + " minutes")
    
Catch ex As Exception
    ' Handle critical errors
    Log Message("CRITICAL", "Bot failed with critical error: " + ex.Message)
    Send Email(
        To:="rpa.support@company.com",
        Subject:="Invoice Processing Bot Failed",
        Body:="Critical error occurred: " + ex.Message,
        Attachments:="latest_error_screenshot.png"
    )
Finally
    ' Cleanup and release resources
    Close All Applications()
    Log Message("INFO", "Bot shutdown completed")
End Try

Step-by-Step Explanation:

Initialization (Lines 6-9): The bot begins by declaring variables for tracking progress and setting up the file path. This establishes the foundation for process monitoring and analytics.
Data Loading (Lines 14-15): The Read CSV activity imports invoice data into a DataTable structure, enabling structured data manipulation and iteration.
Application Integration (Lines 17-25): The bot opens the ERP system and performs secure authentication using credential management, demonstrating best practices for handling sensitive information.
Iterative Processing (Lines 27-71): A For Each loop processes each invoice individually, implementing error handling at the item level to ensure one failure doesn't stop the entire batch.
Error Recovery (Lines 58-68): Individual try-catch blocks capture invoice-specific errors, log details, take screenshots for debugging, and update status tracking without terminating the bot.
Reporting (Lines 76-79): The bot generates comprehensive logs including success counts, error counts, and processing duration for operational monitoring.

Expected Output:

Log Output:
[2024-01-15 09:00:00] INFO: Invoice processing bot started
[2024-01-15 09:00:05] INFO: Loaded 25 invoices for processing
[2024-01-15 09:00:15] INFO: Processing invoice: INV-2024-001
[2024-01-15 09:00:22] SUCCESS: Invoice INV-2024-001 processed. Confirmation: CONF-789456
...
[2024-01-15 09:15:30] INFO: Bot completed. Processed: 23 | Errors: 2 | Duration: 15.50 minutes

Best Practices Demonstrated:

Comprehensive logging at multiple severity levels (INFO, SUCCESS, ERROR, CRITICAL)
Secure credential management instead of hardcoded passwords
Individual item error handling to ensure batch resilience
Screenshot capture for debugging failed transactions
Status tracking and audit trail maintenance
Resource cleanup in Finally block to prevent memory leaks

Common Mistakes to Avoid:

Hardcoding credentials: Always use credential management systems or secure vaults
No error handling: A single error would crash the entire batch without try-catch blocks
Insufficient logging: Inadequate logs make debugging production issues nearly impossible
Missing timeouts: Without Wait For Element timeouts, bots hang indefinitely if screens don't load

Example 2: Attended Bot - Customer Service Assistant

This example illustrates an attended bot that assists customer service representatives by automatically retrieving customer information from multiple systems when a customer ID is entered. This demonstrates real-time human-bot collaboration.


"""
Customer Service Assistant Bot (Attended)
Platform: Python with RPA Framework
Purpose: Retrieve customer 360° view from multiple systems
Trigger: Manual launch by customer service representative
"""

import logging
from datetime import datetime
from RPA.Browser.Selenium import Selenium
from RPA.Excel.Files import Files
from RPA.Windows import Windows
import json

# Initialize RPA components
browser = Selenium()
excel = Files()
windows = Windows()

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('customer_service_bot.log'),
        logging.StreamHandler()
    ]
)

class CustomerServiceBot:
    """Attended bot for customer service representatives"""
    
    def __init__(self):
        self.customer_data = {}
        self.bot_start_time = datetime.now()
        logging.info("Customer Service Assistant Bot initialized")
    
    def get_customer_id_from_user(self):
        """
        Display input dialog for customer ID entry
        Returns: Customer ID entered by user
        """
        try:
            # Show input dialog using Windows automation
            customer_id = windows.show_input_dialog(
                title="Customer Lookup",
                message="Enter Customer ID:",
                default_value="",
                button_labels=["Search", "Cancel"]
            )
            
            if customer_id:
                logging.info(f"User entered Customer ID: {customer_id}")
                return customer_id.strip()
            else:
                logging.warning("User cancelled customer lookup")
                return None
                
        except Exception as e:
            logging.error(f"Error getting customer ID: {str(e)}")
            return None
    
    def retrieve_crm_data(self, customer_id):
        """
        Retrieve customer data from CRM system
        Args: customer_id (str): Customer identifier
        Returns: dict with customer information
        """
        try:
            logging.info(f"Retrieving CRM data for customer: {customer_id}")
            
            # Open CRM web application
            browser.open_available_browser("https://crm.company.com")
            browser.wait_until_page_contains_element("id:search-box", timeout=30)
            
            # Search for customer
            browser.input_text("id:search-box", customer_id)
            browser.click_button("id:search-button")
            browser.wait_until_page_contains_element("class:customer-profile", timeout=10)
            
            # Extract customer information
            customer_name = browser.get_text("id:customer-name")
            customer_email = browser.get_text("id:customer-email")
            customer_phone = browser.get_text("id:customer-phone")
            customer_tier = browser.get_text("id:customer-tier")
            account_status = browser.get_text("id:account-status")
            
            crm_data = {
                "name": customer_name,
                "email": customer_email,
                "phone": customer_phone,
                "tier": customer_tier,
                "status": account_status,
                "source": "CRM"
            }
            
            logging.info(f"Successfully retrieved CRM data for {customer_name}")
            return crm_data
            
        except Exception as e:
            logging.error(f"Failed to retrieve CRM data: {str(e)}")
            return {"error": f"CRM lookup failed: {str(e)}"}
    
    def retrieve_billing_data(self, customer_id):
        """
        Retrieve billing information from billing system
        Args: customer_id (str): Customer identifier
        Returns: dict with billing information
        """
        try:
            logging.info(f"Retrieving billing data for customer: {customer_id}")
            
            # Navigate to billing system
            browser.go_to("https://billing.company.com")
            browser.wait_until_page_contains_element("id:customer-id-input", timeout=30)
            
            # Login if required (using session management)
            if browser.is_element_visible("id:login-form"):
                self._handle_billing_login()
            
            # Query billing information
            browser.input_text("id:customer-id-input", customer_id)
            browser.click_button("id:query-button")
            browser.wait_until_page_contains_element("class:billing-summary", timeout=10)
            
            # Extract billing details
            current_balance = browser.get_text("id:current-balance")
            payment_method = browser.get_text("id:payment-method")
            last_payment_date = browser.get_text("id:last-payment-date")
            last_payment_amount = browser.get_text("id:last-payment-amount")
            next_billing_date = browser.get_text("id:next-billing-date")
            
            billing_data = {
                "current_balance": current_balance,
                "payment_method": payment_method,
                "last_payment_date": last_payment_date,
                "last_payment_amount": last_payment_amount,
                "next_billing_date": next_billing_date,
                "source": "Billing System"
            }
            
            logging.info(f"Successfully retrieved billing data")
            return billing_data
            
        except Exception as e:
            logging.error(f"Failed to retrieve billing data: {str(e)}")
            return {"error": f"Billing lookup failed: {str(e)}"}
    
    def retrieve_support_tickets(self, customer_id):
        """
        Retrieve recent support tickets from ticketing system
        Args: customer_id (str): Customer identifier
        Returns: list of recent support tickets
        """
        try:
            logging.info(f"Retrieving support tickets for customer: {customer_id}")
            
            # Navigate to support ticketing system
            browser.go_to("https://support.company.com")
            browser.wait_until_page_contains_element("id:ticket-search", timeout=30)
            
            # Search for customer tickets
            browser.input_text("id:ticket-search", customer_id)
            browser.select_from_list_by_label("id:search-type", "Customer ID")
            browser.click_button("id:search-tickets-button")
            browser.wait_until_page_contains_element("class:ticket-list", timeout=10)
            
            # Extract ticket information
            tickets = []
            ticket_elements = browser.find_elements("class:ticket-row")
            
            # Limit to 5 most recent tickets
            for i, ticket_elem in enumerate(ticket_elements[:5]):
                ticket_data = {
                    "ticket_id": browser.get_text(f"xpath://div[@class='ticket-row'][{i+1}]/span[@class='ticket-id']"),
                    "subject": browser.get_text(f"xpath://div[@class='ticket-row'][{i+1}]/span[@class='subject']"),
                    "status": browser.get_text(f"xpath://div[@class='ticket-row'][{i+1}]/span[@class='status']"),
                    "created_date": browser.get_text(f"xpath://div[@class='ticket-row'][{i+1}]/span[@class='created']"),
                    "priority": browser.get_text(f"xpath://div[@class='ticket-row'][{i+1}]/span[@class='priority']")
                }
                tickets.append(ticket_data)
            
            logging.info(f"Retrieved {len(tickets)} support tickets")
            return {"tickets": tickets, "source": "Support System"}
            
        except Exception as e:
            logging.error(f"Failed to retrieve support tickets: {str(e)}")
            return {"error": f"Support ticket lookup failed: {str(e)}"}
    
    def generate_customer_summary(self):
        """
        Compile all customer data into comprehensive summary
        Creates an Excel report for the customer service representative
        """
        try:
            logging.info("Generating customer summary report")
            
            # Create new Excel workbook
            excel.create_workbook("Customer_360_View.xlsx")
            excel.create_worksheet("Customer Summary")
            
            # Write customer profile section
            excel.set_cell_value(1, 1, "CUSTOMER 360° VIEW")
            excel.set_cell_value(2, 1, f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
            excel.set_cell_value(3, 1, "")
            
            row = 4
            
            # CRM Data Section
            if "crm" in self.customer_data:
                excel.set_cell_value(row, 1, "=== CRM INFORMATION ===")
                row += 1
                for key, value in self.customer_data["crm"].items():
                    if key != "source" and key != "error":
                        excel.set_cell_value(row, 1, key.replace("_", " ").title())
                        excel.set_cell_value(row, 2, value)
                        row += 1
                row += 1
            
            # Billing Data Section
            if "billing" in self.customer_data:
                excel.set_cell_value(row, 1, "=== BILLING INFORMATION ===")
                row += 1
                for key, value in self.customer_data["billing"].items():
                    if key != "source" and key != "error":
                        excel.set_cell_value(row, 1, key.replace("_", " ").title())
                        excel.set_cell_value(row, 2, value)
                        row += 1
                row += 1
            
            # Support Tickets Section
            if "support" in self.customer_data and "tickets" in self.customer_data["support"]:
                excel.set_cell_value(row, 1, "=== RECENT SUPPORT TICKETS ===")
                row += 1
                excel.set_cell_value(row, 1, "Ticket ID")
                excel.set_cell_value(row, 2, "Subject")
                excel.set_cell_value(row, 3, "Status")
                excel.set_cell_value(row, 4, "Priority")
                excel.set_cell_value(row, 5, "Created Date")
                row += 1
                
                for ticket in self.customer_data["support"]["tickets"]:
                    excel.set_cell_value(row, 1, ticket["ticket_id"])
                    excel.set_cell_value(row, 2, ticket["subject"])
                    excel.set_cell_value(row, 3, ticket["status"])
                    excel.set_cell_value(row, 4, ticket["priority"])
                    excel.set_cell_value(row, 5, ticket["created_date"])
                    row += 1
            
            # Save and open workbook
            excel.save_workbook()
            excel.close_workbook()
            
            # Open the generated report for the user
            windows.open_file("Customer_360_View.xlsx")
            
            logging.info("Customer summary report generated successfully")
            
        except Exception as e:
            logging.error(f"Failed to generate customer summary: {str(e)}")
    
    def run(self):
        """
        Main execution flow for attended bot
        """
        try:
            # Get customer ID from user
            customer_id = self.get_customer_id_from_user()
            
            if not customer_id:
                logging.info("Bot execution cancelled by user")
                return
            
            # Show progress indicator to user
            windows.show_message_dialog(
                title="Processing",
                message=f"Retrieving information for customer {customer_id}...\nPlease wait.",
                timeout=2000  # Auto-close after 2 seconds
            )
            
            # Retrieve data from all systems
            self.customer_data["crm"] = self.retrieve_crm_data(customer_id)
            self.customer_data["billing"] = self.retrieve_billing_data(customer_id)
            self.customer_data["support"] = self.retrieve_support_tickets(customer_id)
            
            # Generate comprehensive report
            self.generate_customer_summary()
            
            # Calculate processing time
            processing_time = (datetime.now() - self.bot_start_time).total_seconds()
            
            # Show completion message
            windows.show_message_dialog(
                title="Complete",
                message=f"Customer 360° view generated successfully!\nProcessing time: {processing_time:.2f} seconds\nReport opened in Excel.",
                timeout=5000
            )
            
            logging.info(f"Bot execution completed in {processing_time:.2f} seconds")
            
        except Exception as e:
            logging.error(f"Bot execution failed: {str(e)}")
            windows.show_message_dialog(
                title="Error",
                message=f"An error occurred: {str(e)}\nPlease contact RPA support.",
                timeout=10000
            )
        
        finally:
            # Cleanup
            browser.close_all_browsers()
            logging.info("Bot cleanup completed")

# Main execution
if __name__ == "__main__":
    bot = CustomerServiceBot()
    bot.run()

Step-by-Step Explanation:

Bot Initialization (Lines 29-35): The bot initializes as a class with proper logging configuration, enabling structured development and reusability.
User Interaction (Lines 37-56): The get_customer_id_from_user method demonstrates attended bot characteristics by displaying a dialog and waiting for user input.
Multi-System Integration (Lines 58-145): Three separate methods retrieve data from CRM, Billing, and Support systems, demonstrating how RPA consolidates information from disparate applications.
Data Aggregation (Lines 147-218): The generate_customer_summary method compiles data from multiple sources into a unified Excel report, providing the representative with a complete customer view.
Main Execution Flow (Lines 220-260): The run method orchestrates the entire process, including progress indication and error handling with user-friendly messages.

Expected Output:

An Excel file containing:
- Customer name, email, phone, tier status
- Current balance, payment method, billing dates
- List of 5 most recent support tickets with status

Processing time: Typically 15-30 seconds (vs. 5-10 minutes manual lookup)

Best Practices Demonstrated:

Object-oriented design for maintainability and reusability
User interaction through dialogs for attended bot scenarios
Progress indicators to keep users informed during processing
Graceful error handling with user-friendly messaging
Automatic opening of generated reports for immediate use
Comprehensive logging for support and debugging

Example 3: Unattended Bot - Nightly Data Reconciliation

This example showcases an unattended bot that runs on a schedule to reconcile data between two systems, identifying discrepancies and generating exception reports. This is a typical back-office automation scenario.


/**
 * Nightly Data Reconciliation Bot (Unattended)
 * Platform: Automation Anywhere A360
 * Purpose: Compare inventory data between ERP and Warehouse Management System
 * Schedule: Daily at 2:00 AM
 * Expected Duration: 30-45 minutes for 5,000 SKUs
 */

// Import required packages
import { Database } from 'automation-anywhere-database';
import { Excel } from 'automation-anywhere-excel';
import { Email } from 'automation-anywhere-email';
import { Logger } from 'automation-anywhere-logger';
import { DateTime } from 'automation-anywhere-datetime';

// Initialize bot components
const db = new Database();
const excel = new Excel();
const email = new Email();
const logger = new Logger('DataReconciliationBot');

// Configuration constants
const ERP_CONNECTION = {
    host: '${credential.erp_db_host}',
    database: 'ERP_Production',
    username: '${credential.erp_db_user}',
    password: '${credential.erp_db_password}'
};

const WMS_CONNECTION = {
    host: '${credential.wms_db_host}',
    database: 'WMS_Production',
    username: '${credential.wms_db_user}',
    password: '${credential.wms_db_password}'
};

const RECONCILIATION_CONFIG = {
    tolerancePercentage: 2.0,  // Allow 2% variance before flagging
    reportPath: 'C:\\RPA\\Reports\\Reconciliation\\',
    archivePath: 'C:\\RPA\\Archive\\Reconciliation\\',
    emailRecipients: ['inventory.manager@company.com', 'operations.director@company.com'],
    criticalThreshold: 50  // Number of discrepancies to trigger urgent alert
};

// Main bot class
class DataReconciliationBot {
    constructor() {
        this.startTime = new Date();
        this.statistics = {
            totalRecords: 0,
            matched: 0,
            discrepancies: 0,
            errors: 0,
            erpOnlyRecords: 0,
            wmsOnlyRecords: 0
        };
        this.discrepancyDetails = [];
        
        logger.info('Data Reconciliation Bot initialized');
    }
    
    /**
     * Extract inventory data from ERP system
     * Returns: Array of inventory records
     */
    async extractERPInventory() {
        try {
            logger.info('Connecting to ERP database...');
            
            // Establish database connection
            await db.connect(ERP_CONNECTION);
            
            // Query inventory data
            const query = `
                SELECT 
                    SKU,
                    ProductName,
                    Quantity,
                    UnitCost,
                    Location,
                    LastUpdated,
                    InventoryValue
                FROM Inventory.CurrentStock
                WHERE IsActive = 1
                ORDER BY SKU
            `;
            
            logger.info('Executing ERP inventory query...');
            const erpData = await db.executeQuery(query);
            
            logger.info(`Retrieved ${erpData.length} records from ERP`);
            
            // Close database connection
            await db.disconnect();
            
            return erpData;
            
        } catch (error) {
            logger.error(`Failed to extract ERP inventory: ${error.message}`);
            throw error;
        }
    }
    
    /**
     * Extract inventory data from Warehouse Management System
     * Returns: Array of inventory records
     */
    async extractWMSInventory() {
        try {
            logger.info('Connecting to WMS database...');
            
            // Establish database connection
            await db.connect(WMS_CONNECTION);
            
            // Query warehouse inventory data
            const query = `
                SELECT 
                    ItemCode AS SKU,
                    ItemDescription AS ProductName,
                    OnHandQuantity AS Quantity,
                    AverageCost AS UnitCost,
                    WarehouseLocation AS Location,
                    LastModified AS LastUpdated,
                    (OnHandQuantity * AverageCost) AS InventoryValue
                FROM Warehouse.StockLevels
                WHERE Status = 'ACTIVE'
                ORDER BY ItemCode
            `;
            
            logger.info('Executing WMS inventory query...');