RPA Script Logic AI Prompts for Automation Engineers

RPA projects fail in predictable ways. The automation works perfectly in development. It breaks in production. The selector that was reliable last week fails today. The screen layout changed and nobody told you. The robot crashes because of an unexpected popup.

These failures are not bugs in the traditional sense. They are brittleness. RPA is brittle because it relies on assumptions about the user interface that are outside your control. Applications change. Developers make UI changes without warning. Third-party systems evolve. Your automation breaks.

Traditional RPA development treats symptoms. You add exception handlers. You add retry logic. You add screenshot logging. You wait for something to break and then you fix it.

The better approach is to build resilience into your automation from the start. This means better selectors, better error handling, better recovery logic, and better monitoring. AI can help you design more robust automation logic and anticipate failure modes before they occur.

AI Unpacker provides prompts designed to help automation engineers build RPA scripts that are resilient, maintainable, and production-ready.

TL;DR

• RPA brittleness comes from fragile selectors and poor error handling.
• Robust automation anticipates failure instead of reacting to it.
• Better selectors and recovery logic prevent most production failures.
• AI can help design resilient automation logic.
• Monitoring and alerting catch failures before they become incidents.
• Test automation in production-like environments before deployment.

Introduction

Robotic Process Automation promises to eliminate repetitive manual work. The reality is more complex. RPA projects succeed at automating individual tasks but struggle to scale. They require constant maintenance. They break when applications change. They need debugging when they encounter unexpected situations.

The root cause is architectural. RPA was designed to mimic human actions at the user interface level. This makes it accessible to business users without programming experience. It also makes it inherently fragile. The UI was not designed for automation. It was designed for human interaction.

The solution is not to abandon RPA. It is to use it more intelligently. Build automation that is resilient to change. Design selectors that are robust. Implement error handling that recovers gracefully. Monitor automation in production so you know when it breaks.

AI can help you design better automation logic. It can help you identify failure modes, suggest robust selectors, and generate recovery logic. It cannot replace your understanding of the business process, but it can accelerate the technical implementation.

1. Process Analysis and Decomposition

Before automating, you need to understand the process thoroughly. Most automation failures come from incomplete process understanding.

Prompt for Process Analysis

Analyze process for RPA automation.

Process: Invoice processing in ERP system
Current manual process:
1. Receive invoice via email (PDF attachment)
2. Open email and download PDF
3. Open ERP system and navigate to invoice entry screen
4. Manually enter: vendor name, invoice number, date, line items, amounts
5. Attach PDF to ERP record
6. Submit for approval
7. Route to appropriate approver based on amount
8. Receive approval notification
9. Match invoice to purchase order if exists
10. Flag discrepancies for review
11. Schedule for payment
12. Update vendor records if needed

Manual process metrics:
- Time per invoice: 15 minutes
- Error rate: 5% (data entry mistakes)
- Volume: 50 invoices/day
- Peak: Month-end (150 invoices/day)

Process variations:
- Invoices with PO match: Standard flow (70%)
- Invoices without PO match: Requires exception handling (20%)
- Invoices with discrepancies: Requires escalation (10%)
- Vendor setup needed: Requires new vendor workflow (rare)

Automation opportunities:

Task 1: Email processing
- Automate: Detect new emails, download attachments
- Challenges: Multiple email formats, password-protected PDFs, spam filtering
- Risk: Medium - failures visible and recoverable

Task 2: Data extraction
- Automate: Extract vendor, invoice number, date, line items, amounts from PDF
- Challenges: Varying PDF formats, poor OCR quality, handwritten elements
- Risk: High - errors propagate through system

Task 3: ERP navigation
- Automate: Log in, navigate to invoice entry, enter data
- Challenges: Session timeouts, popups, UI changes
- Risk: High - depends on stable UI

Task 4: Approval routing
- Automate: Route based on amount thresholds
- Challenges: Exception handling, approver availability
- Risk: Medium - failures can be manually corrected

Task 5: PO matching
- Automate: Match invoice to PO based on vendor + amount + items
- Challenges: Incomplete POs, partial matches, encoding differences
- Risk: High - mismatches cause financial problems

What cannot be automated:
- Judgment on discrepancies (requires human decision)
- Vendor setup edge cases (requires verification)
- Complex exception handling (varies by situation)
- Anything requiring document signing

Automation approach:

Option 1: Full end-to-end automation
- Automate everything that can be automated
- Route exceptions to human review
- Pros: Maximum efficiency
- Cons: High complexity, fragile

Option 2: Human-in-the-loop automation
- Automate data extraction and entry
- Human reviews and approves before submission
- Pros: More reliable, human judgment available
- Cons: Less efficiency gain

Option 3: Task automation
- Automate only specific tasks (email download, ERP entry)
- Keep approval workflow manual
- Pros: Simpler, more reliable
- Cons: Less efficiency gain

Recommended approach: Hybrid
- Automate: Email processing, data extraction, ERP entry, PO matching
- Human-in-the-loop: Exception handling, approval routing, discrepancy review
- Fully manual: Complex exceptions, vendor setup

Tasks:
1. Map complete process flow with decision points
2. Identify automation opportunities with risk levels
3. Design human-in-the-loop integration points
4. Define exception handling for each failure mode
5. Estimate efficiency gain and implementation cost

Generate process analysis with automation approach and risk assessment.

2. Robust Selector Design

Selectors are the Achilles heel of RPA. They are brittle by nature. Better selector design is the key to resilient automation.

Prompt for Selector Design

Design robust selectors for ERP invoice automation.

Application: Web-based ERP system
Target elements: Invoice entry form fields, buttons, table rows

Common selector problems:
1. Dynamic IDs (change on each page load)
2. Position-based selectors (break when layout changes)
3. Text-based selectors (break when language changes)
4. Index-based selectors (break when rows are added/removed)

Selector types and stability:

Type 1: Anchor-based selectors (Most reliable)
- Use stable elements as anchors
- Find target relative to anchors
- Example: "Find input field with label 'Vendor Name' near button with text 'Submit'"

Type 2: Semantic selectors (Very reliable)
- Use meaningful attributes
- Avoid generated or dynamic attributes
- Example: "aria-label='Vendor Name'" or "placeholder='Enter vendor name'"

Type 3: CSS selectors (Moderately reliable)
- Use specific, stable attributes
- Avoid selectors with many conditions
- Example: "input[id$='vendorName']" (ends with)

Type 4: XPath (Least reliable)
- Fragile to minor changes
- Position-dependent
- Use only when no better option

Selector strategy for each element:

Element: Vendor name input field
- Best: Semantic "[aria-label='Vendor Name']"
- Fallback: "input[id$='vendorName']"
- Anchor: Near "Invoice Details" header
- Verify: Field contains expected placeholder

Element: Submit button
- Best: Semantic "button[type='submit']" or "[aria-label='Submit']"
- Fallback: "button:contains('Submit')"
- Anchor: Below form fields
- Verify: Button is visible and enabled

Element: Invoice line item row
- Best: Table row with semantic class "[class='invoice-line']"
- Fallback: "tr:has(td:nth-child(2))" (row with at least 2 cells)
- Anchor: Within invoice items table
- Verify: Row contains expected column structure

Element: Approval amount threshold
- Best: Static text element with consistent label
- Fallback: Position-based if text stable
- Anchor: Near approval routing section
- Verify: Amount matches configured threshold

Dynamic handling strategies:

Strategy 1: Wildcard patterns
- Instead of: "input[id='invoice2024']"
- Use: "input[id*='invoice']"
- Catches variations while staying specific

Strategy 2: Multiple fallback selectors
- Try: Semantic selector first
- Fallback 1: Attribute-based selector
- Fallback 2: Anchor-relative selector
- Fallback 3: Image recognition (last resort)

Strategy 3: Visual anchoring
- Find stable visual element near target
- Calculate relative position
- Use offset from anchor
- Example: "24 pixels right of 'Vendor Name' label"

Strategy 4: Smart wait conditions
- Wait for element to be present (not just visible)
- Wait for element to be stable (not animating)
- Wait with timeout, fail gracefully if not found

Selector verification:

What to verify after selection:
1. Element is found within timeout
2. Element is visible (not hidden)
3. Element is enabled (not disabled)
4. Element contains expected content/attributes
5. Element is in expected position

What to do if verification fails:
1. Log failure with screenshot
2. Try fallback selector
3. Try anchor-based relocation
4. Raise exception for human review

Tasks:
1. Map all UI elements needing selectors
2. Identify stable semantic attributes
3. Define fallback selector chain for each element
4. Design verification logic for each selector
5. Create recovery logic for selector failures

Generate robust selector design with fallback chains and verification logic.

3. Error Handling and Recovery

Production RPA fails. Your job is to make it fail gracefully. Good error handling catches failures early, recovers when possible, and escalates when needed.

Prompt for Error Handling Design

Design error handling for invoice processing RPA.

Automation flow:
1. Read email and download attachment
2. Extract data from invoice PDF
3. Log into ERP system
4. Navigate to invoice entry
5. Enter invoice data
6. Match to PO if exists
7. Submit for approval
8. Log completion

Error scenarios:

Error 1: Email processing failure
- Problem: Email not found, attachment missing, wrong format
- Detection: File not found, parse error, timeout waiting for email
- Recovery: Retry 3 times, skip if persistent, log for manual review
- Escalation: Alert if >10% failure rate

Error 2: PDF extraction failure
- Problem: OCR fails, PDF is image-based, corrupted file
- Detection: Parser exception, empty extraction results
- Recovery: Retry with different settings, flag for manual extraction
- Escalation: Alert if >5% failure rate

Error 3: ERP login failure
- Problem: Wrong credentials, account locked, 2FA required
- Detection: Login error message, session creation failure
- Recovery: Check credentials, alert for credential issues
- Escalation: Immediate alert (blocks all processing)

Error 4: Navigation failure
- Problem: Screen changed, element not found, popup blocking
- Detection: Element not found after timeout
- Recovery: Retry with longer wait, try fallback selectors
- Escalation: Alert if navigation fails after retries

Error 5: Data entry failure
- Problem: Field validation error, format rejected, session timeout
- Detection: Error message returned, field highlight, validation failure
- Recovery: Clear field, retry entry, refresh session if needed
- Escalation: Manual review if persistent

Error 6: PO matching failure
- Problem: No matching PO, partial match, duplicate detected
- Detection: No PO found for vendor+amount+items
- Recovery: Route to manual matching queue
- Escalation: Alert on high-value unmatched invoices

Error 7: Submission failure
- Problem: Validation failed, approval routing error, system timeout
- Detection: Submission error message, confirmation not received
- Recovery: Verify data, retry submission, refresh session
- Escalation: Manual intervention required

Recovery framework:

Layer 1: Immediate retry
- For: Transient failures (timeout, temporary unavailability)
- Action: Wait 5 seconds, retry once
- Log: Retry attempt and result

Layer 2: Fallback recovery
- For: Element not found, action failed
- Action: Use alternative selector or method, retry
- Log: Fallback used and result

Layer 3: Skip and flag
- For: Recoverable but persistent failures
- Action: Skip current item, flag for manual processing, continue with next
- Log: Item skipped, reason, manual queue entry

Layer 4: Stop and escalate
- For: Non-recoverable failures that block automation
- Action: Stop automation, alert immediately, create incident
- Log: Full context, screenshots, system state

Error logging requirements:
1. Timestamp of error
2. Step where error occurred
3. Element or action that failed
4. Error message or exception
5. Screenshot at moment of failure
6. State of application (values entered, screens shown)
7. Recovery action taken
8. Resolution

Alerting thresholds:
- Critical: ERP login failure, submission failure (immediate alert)
- High: >10% email processing failures (within 1 hour)
- Medium: >5% extraction failures (daily summary)
- Low: Any error rate above baseline (weekly review)

Tasks:
1. Map all error scenarios for each automation step
2. Define recovery action for each error
3. Set alerting thresholds by severity
4. Create error logging template
5. Design escalation workflow

Generate error handling framework with recovery logic and escalation paths.

4. Production Monitoring Setup

You cannot fix what you cannot see. Production monitoring is essential for maintaining reliable RPA.

Prompt for Monitoring Setup

Set up production monitoring for invoice RPA.

Metrics to track:

Execution metrics:
1. Robot execution count (how many invoices processed)
2. Success rate (percentage completed without errors)
3. Failure rate (percentage failed at each step)
4. Average processing time per invoice
5. Peak processing time (slowest invoice)

Error metrics:
1. Errors by type (email, extraction, ERP, etc.)
2. Errors by frequency (most common failures)
3. Error rate trend over time
4. Recovery success rate (how often retries work)
5. Escalation rate (how often human intervention needed)

Business metrics:
1. Invoices processed per day
2. Straight-through processing rate (no human needed)
3. Exception queue depth
4. Average exception resolution time
5. Auto-matched PO rate

System metrics:
1. Robot uptime
2. System response time
3. Session timeout frequency
4. Network reliability

Monitoring implementation:

Real-time monitoring (for active execution):
- Dashboard showing: Current status, invoices being processed, recent errors
- Alerts: Immediate notification of critical failures
- Tools: RPA platform native monitoring, Slack integration

Daily metrics review:
- Automated daily report at end of business day
- Summary of: Invoices processed, success rate, exceptions
- Trend: Comparison to previous days
- Action items: Exceptions needing attention

Weekly analysis:
- Error pattern identification
- Trend analysis
- Capacity planning
- Improvement opportunities

Alert configuration:

Alert 1: Critical error during execution
- Trigger: Login failure, submission failure, system unavailable
- Action: Immediate Slack notification to on-call
- Response time: < 15 minutes

Alert 2: Error rate spike
- Trigger: Error rate exceeds threshold (configurable, default 10%)
- Action: Slack notification to team channel
- Response time: < 1 hour

Alert 3: Exception queue backup
- Trigger: Unprocessed exceptions > 10 for > 2 hours
- Action: Email notification to operations team
- Response time: < 4 hours

Alert 4: Performance degradation
- Trigger: Average processing time exceeds threshold
- Action: Daily summary notification
- Response time: Next business day

Dashboard design:

Main dashboard view:
- Invoices processed today (big number)
- Success rate (percentage with trend)
- Exceptions requiring attention (count)
- Last 24 hours activity (mini chart)
- Recent errors (scrollable list)

Detail views:
- By robot (which automation is having issues)
- By error type (aggregate view of error patterns)
- By time (identify patterns by hour/day)
- By operator (who is handling exceptions)

What to log for debugging:
1. Full execution log (every action taken)
2. Screenshots on error
3. Application state (all visible elements)
4. Data state (values being processed)
5. Timing information (how long each step took)

Health check protocol:
- Run health check every 15 minutes during execution window
- Verify: System accessible, credentials valid, queue accessible
- Alert if health check fails

Tasks:
1. Define monitoring metrics and thresholds
2. Set up real-time dashboard
3. Configure alerting rules
4. Create daily/weekly report templates
5. Establish incident response workflow

Generate production monitoring plan with metrics, alerts, and dashboards.

FAQ

How do I reduce selector brittleness?

Use semantic selectors when possible (aria-label, placeholder, id). Build fallback chains with multiple selector strategies. Use visual anchoring (finding elements relative to stable nearby elements). Implement smart waiting (wait for stability, not just presence). When possible, work with application teams to add automation-friendly attributes.

How often should I test my RPA in production?

Continuously monitor in production. Additionally, test before any application updates, after any RPA changes, and periodically (weekly) with known test cases. If the application changes frequently, consider more frequent testing.

What is the best practice for exception handling?

Design for exceptions from the start. Log thoroughly (you cannot debug what you cannot see). Have clear escalation paths. Distinguish between recoverable errors (retry) and non-recoverable errors (escalate). Minimize human intervention required for common exceptions.

How do I know if my RPA is cost-effective?

Track automation metrics: hours saved, error rate reduction, throughput improvement. Calculate cost of automation (licenses, development, maintenance). Compare to manual process cost. If automation cost < manual cost over expected lifetime, it is cost-effective. Also consider strategic value of freed-up human time.

Conclusion

Robust RPA is built on robust design. Brittle selectors, poor error handling, and lack of monitoring are the root causes of most RPA failures. Building resilience requires anticipating failures, not just reacting to them.

AI Unpacker gives you prompts to analyze processes, design robust selectors, build error handling, and set up monitoring. But the diligence to test thoroughly, the discipline to maintain monitoring, and the judgment about when automation is appropriate — those come from you.

The goal is not automation that works in development. The goal is automation that works reliably in production.