Portal Cleaner Ultimate: Resilient RPA & Inventory Sync Engine

Overview

In both industrial operations (like Platech Coating) and e-commerce ventures (like my collectibles micro-venture zidorun), updating inventory records, pricing, and orders across multiple web platforms is a major operational bottleneck. Manually entering this data into legacy ERP portals is slow, error-prone, and repetitive.

To solve this, I designed and built Portal Cleaner Ultimate, a desktop RPA (Robotic Process Automation) suite. By combining a multithreaded Python backend, Selenium automation, and a custom offline test harness, this engine reduces manual data entry workloads by 90%+, processing over 700 live transactions with a 99% success rate.

---

Results at a Glance

Performance Dimension	Manual Ingestion	Portal Cleaner Ultimate	Impact
Daily Processing Time	4–6 hours	< 30 minutes	90%+ Workload Reduction
Transaction Success Rate	~92% (Human error)	99.1% (700+ transactions)	Major reduction in sync errors
GUI Responsiveness	N/A	Fully responsive UI (Tkinter)	Retaining-free user control
Testing Infrastructure	Live production site	Local Mock ERP Harness	Zero risk of account bans during test

---

Phase 1: Architecture — Multithreaded GUI Pattern

A frequent pitfall in desktop automation tools is UI freezing. If the automation script runs on the main thread, the user interface stops responding while the browser is loading or scraping data.

Portal Cleaner Ultimate addresses this by splitting the application into two distinct threads:

sequenceDiagram
    participant User as Tkinter GUI (Main Thread)
    participant Queue as Thread-Safe Queue
    participant Worker as Automation Thread (Selenium)
    participant Browser as Chrome/Firefox Driver

    User->>Queue: Push Task (Start Sync)
    Worker->>Queue: Poll Task
    Worker->>Browser: Launch Web Driver
    loop Automation Loop
        Browser->>Worker: Page Source / State
        Worker->>Queue: Progress Status ("50% Done")
        Queue->>User: Update Progress Bar
    end
    Worker->>Browser: Close Session
    Worker->>Queue: Job Complete ("Done")
    Queue->>User: Update UI to Idle

• Main Thread (Tkinter GUI): Handles user interactions, updates progress bars, and processes cancellation signals.
• Worker Thread (Background Process): Initializes the Selenium webdriver, handles browser actions, and parses data.
• Communication: Standard, thread-safe Python queue.Queue channels transfer status updates and cancellation requests between the threads.

class RPAWorker(threading.Thread):
    def __init__(self, task_queue, gui_queue):
        super().__init__()
        self.task_queue = task_queue
        self.gui_queue = gui_queue
        self.daemon = True

    def run(self):
        while True:
            task = self.task_queue.get()
            try:
                self.execute_automation(task)
            except Exception as e:
                self.gui_queue.put({"type": "ERROR", "msg": str(e)})
            finally:
                self.task_queue.task_done()

---

Phase 2: Offline Mock ERP Test-Harness

Testing web scraping and automated form submission directly on production websites is risky. It can lead to account bans, rate limiting, and database pollution.

To prevent this, I engineered a local Mock ERP Test-Harness. This is a standalone HTML/JS application running locally that mimics the structure and behavior of target enterprise portals:

1. Simulated Server Latency: JavaScript delay functions mimic slow loading speeds (varying from 100ms to 4000ms).
2. Injected HTTP Errors: A control panel allows developers to inject simulated failures (such as 500 Internal Server Error, 403 Forbidden, or validation errors) to verify how the RPA script handles network issues.
3. Dynamic Forms: Renders forms with shifting element IDs (similar to modern web apps) to test the robustness of XPath and CSS selectors.

This harness allowed for extensive, offline end-to-end integration testing, ensuring the script was highly stable before interacting with live customer data.

---

Phase 3: The Resilient Ingestion Engine

Web automation scripts frequently fail when pages load slower than expected. To handle these real-world network fluctuations, Portal Cleaner Ultimate includes a built-in recovery engine:

• Dynamic Waiting: Rather than using hardcoded sleep times (time.sleep(5)), the script uses Selenium’s WebDriverWait to monitor the page and act as soon as an element is loaded, improving efficiency.
• Exponential Backoff Retries: If a page fails to load or an element is missing, the engine retries the action, increasing the wait time with each attempt:

def retry_on_failure(max_retries=3, initial_delay=2.0):
    def decorator(func):
        def wrapper(*args, **kwargs):
            delay = initial_delay
            for attempt in range(max_retries):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    if attempt == max_retries - 1:
                        raise e
                    time.sleep(delay)
                    delay *= 2  # Double the wait time for the next attempt
            return None
        return wrapper
    return decorator

---

Phase 4: Production Case Study — zidorun Sync

For zidorun, a collectibles micro-venture I founded, I deployed a customized version of this RPA engine to synchronize inventory and price details across Turkish e-commerce channels.

• Inventory Synchronization: When an item sold on one channel, the engine automatically logged into the other platforms, updated the stock levels, and sent a success confirmation.
• Financial Validation: The engine processed 700+ transactions and cross-referenced prices with a local database to ensure correct payouts, achieving a 99.1% success rate.

Portal Cleaner Ultimate demonstrates that custom, lightweight Python desktop automation can match the reliability of expensive enterprise RPA platforms at a fraction of the cost.