The objective is to build systems that are not only automated but also robust. As Alfred Leppänen, Intelligent Automation Team Lead at Siili Solutions, states, the goal is a "zero incident philosophy." He clarifies, "We build our automations to be as stable and predictable as possible, assuming that changes in target systems are inevitable." This principle of defensive design is the cornerstone of automation that works in the real world.
This article breaks down the key architectural principles and technical strategies for building resilient, production-ready intelligent automation.
Core architectural principles for stable, resilient automation
A production-ready automation system is an exercise in distributed systems engineering and must be designed with the assumption that failure is a normal operating condition. This requires moving beyond linear scripting to embrace patterns that ensure stability and maintainability.
- Advanced error handling and recovery pathways: Simple try-catch blocks are insufficient. A mature architecture employs tiered recovery strategies: transient errors might trigger a retry loop with exponential backoff; persistent but known errors can invoke an alternative interaction pathway; and unrecoverable errors should trigger a graceful failure that places the task into a human-in-the-loop (HITL) queue with a complete state snapshot for manual intervention. "If you integrate error logic or conditional logic, so that if one event happens, another event triggers, the system can adapt," Leppänen notes.
- Dynamic and multi-modal UI interaction: Static selectors (e.g., XPath, CSS ID) are the primary source of fragility in UI automation. A resilient system uses a multi-modal approach to identify on-screen components. This includes computer vision (CV) for feature-based matching of visual elements, OCR for text recognition within components, and DOM structure analysis for a more holistic understanding of the page layout. This allows the automation to find a target element even after front-end code deployments have altered its specific ID or class.
- Data integrity and in-stream validation: Data validation should not be a post-processing step; it must be integrated throughout the automation pipeline. This includes schema validation on data ingress, checksums for data in transit, and cross-system reconciliation checks to ensure consistency. For example, before committing a record, an automation should query the target system to validate that the preconditions for the update are still met, preventing race conditions and data corruption.
Strategies for automating non-API legacy systems
Legacy systems, such as monolithic desktop clients or mainframe terminals, represent a significant challenge. Success requires disciplined environment management and sophisticated interaction techniques.
Case: The University of Oulu
The University of Oulu sought to eliminate manual, repetitive work in key administrative areas and ensure the quality of a major system upgrade. The university needed to automate the high-volume archiving of employment contracts and theses and also required a method for validating a massive database migration without thousands of hours of manual testing. We delivered a sustainable automation solution to address both challenges using a cost-effective, open-source technology stack. The solution includes two distinct automations:
- Automated document archiving for HR and academic units: A robot continuously monitors specific inboxes for incoming theses, extracts key data, and archives the documents in the correct system, reducing manual labor and eliminating errors.
- Large-scale acceptance testing for a database migration: A validation robot was deployed to perform quality assurance on hundreds of thousands of migrated documents. The bot systematically checked a statistically significant sample (~15%) of the files to confirm data integrity and downloadability.
- Delivered as a Robot as a Service (RaaS) model: The automations are provided as a fully managed service, allowing the university to benefit from the efficiency gains without needing to manage the underlying infrastructure.
- Utilizes an open-source and cloud-based stack: The solution is built on Python, Robot Framework, and Jenkins, running on Amazon Web Services (AWS) for maximum flexibility and cost-efficiency.
The University of Oulu project is a practical example of applying pragmatic RPA to solve distinct business and technical challenges. Instead of a single monolithic bot, the architecture features two independent, fit-for-purpose automations.
The archiving bot handles a continuous, operational process, while the migration validation bot addresses a one-time, critical project need. This validation bot, in particular, demonstrates a sophisticated approach to quality assurance, using an automated random sampling methodology to verify a massive dataset where 100% manual verification would be impossible, thereby ensuring the migration's success and saving thousands of work hours.
The deployment at the University of Oulu, involving both high-volume document archiving and a large-scale data migration validation, highlights several critical strategies. The most crucial is achieving environment parity. "You have to have a very solid development interface of the legacy system that parallels the production system," Leppänen emphasizes. "When we're automating legacy systems, we need to be able to confidently implement them in production."
Achieving this parity is a non-trivial technical challenge due to:
- Data access and privacy constraints: "You can't easily transfer production data back to the development side for multiple reasons: GDPR concerns, security reasons," he explains. The solution is high-fidelity synthetic data generation—creating datasets that respect not only the data schema but also the relational integrity, statistical distributions, and business logic of production data.
- Configuration and network drift: Production environments often have different network ACLs, authentication mechanisms, and API endpoints. All configuration—including timeouts, credentials, and feature flags—must be externalized from the automation code and managed per environment, following standard DevOps practices.
Architecting for intelligent decisioning
Integrating AI/ML models to move from procedural task automation to intelligent decisioning requires a deliberate architectural shift. The primary goal is to decouple the AI models from the business logic of the automation workflow.
This pattern allows data science teams to retrain and deploy new model versions via an MLOps pipeline without requiring a full redeployment of the automation bot. The automation orchestrator interacts with the ML model through a stable API endpoint, treating it as a stateless decision service.
Case: FEON
Feon, one of Finland’s largest steel service companies, aimed to streamline the process of handling product information sheets from their global suppliers. These files needed to be uploaded into the master data system and linked with existing items using the extracted data. We implemented an intelligent automation solution to manage the task end-to-end.
The solution included:
- Collecting relevant emails and extracting attached files: Product information sheets are automatically collected and prepared for processing.
- Validating and extracting data using Azure Document Intelligence AI Models powered by machine learning: Extracts structured data from diverse formats of product information sheets, ensuring high accuracy.
- Generating JSON responses that are validated and processed by the robot: Data is structured into JSON format for streamlined validation and robotic processing.
- Sending extracted data to the master data system via API for updating product records: Ensures extracted information is accurately integrated and linked with existing items in the master data system.
- Sending detailed email reports for client review after each execution: Provides transparency into the data processed and automation performance.
Feon's document processing system is a practical example of a multi-model pipeline architecture. Instead of a single monolithic model, the workflow is composed of:
- A classifier model to identify the document's origin (e.g., which of the 11 suppliers it came from).
- A call to a supplier-specific extractor model, which is highly tuned for that supplier's unique document layout.
- A post-processing and validation layer that applies business rules to the extracted JSON data before integration.
Monitoring, metrics, and MLOps for automation
Monitoring must evolve beyond simple success/failure metrics. A comprehensive strategy provides insight into both the technical health of the system and its business impact, adopting principles from MLOps to manage the AI components.
The automation portfolio at the Finnish pension company Elo exemplifies this. Their systems track not only FTE savings (4 FTEs saved in one process) but also technical KPIs that are precursors to failure. Key metrics include:
- Technical performance: Bot resource utilization (CPU/Memory), API call latency, message queue depth, and database transaction times.
- Model performance: Tracking model drift by monitoring confidence scores in production. When scores for an OCR or classification model consistently drop below a certain threshold, it automatically triggers an alert for model retraining.
- Business impact: Cost per transaction, SLA compliance, and end-to-end process cycle time.
For intelligent systems like Feon's, the monitoring is even more granular. The system tracks extraction accuracy per supplier model, creating a feedback loop where low-confidence extractions are flagged for human review. These corrections are then used as training data for the next iteration of the model, creating a continuous improvement cycle.
The engineering discipline of intelligent automation
Successfully implementing and scaling intelligent automation is a software engineering discipline, not a low-code shortcut. It demands a focus on robust architecture, defensive design, and disciplined DevOps and MLOps practices. The technical choices made regarding error handling, UI interaction, AI model integration, and monitoring are what determine whether an automation initiative delivers sustained, long-term value or becomes a source of technical debt.
The future advantage belongs to organizations that treat intelligent automation with this level of engineering rigor, building systems that can not only leverage current AI capabilities but can also seamlessly and reliably integrate the more advanced technologies of tomorrow.
About
Alfred Leppänen is an experienced Automation Expert and Data Engineer specializing in Python, Robot Framework, and RPA, with over four years of expertise in building end-to-end solutions and integrating open-source technologies. As the Team Lead for the automation tribe at Siili, Alfred drives the adoption of Intelligent Automation and AI Agents, transforming workflows with innovative solutions.
