Low-Code/No-Code Platforms: Enterprise Automation

# Power Automate Flow Example
flow:
  name: "Invoice Approval Workflow"
  trigger:
    type: "When a file is created"
    location: "SharePoint - Documents"
    
  steps:
    - id: 1
      action: "Get file properties"
      inputs:
        Site: "https://contoso.sharepoint.com/sites/Finance"
        Library: "Invoices"
        
    - id: 2
      action: "Get file content"
      inputs:
        File: "Id from step 1"
        
    - id: 3
      action: "Extract text from image (OCR)"
      inputs:
        Source: "File content from step 2"
        
    - id: 4
      action: "Parse JSON"
      inputs:
        Content: "OCR results"
        
    - id: 5
      action: "Condition"
      expression: "@greater(float(outputs('Parse_JSON')?['Amount']), 10000)"
      
      # If Amount > 10000
      if_yes:
        - action: "Start and wait for approval"
          inputs:
            Assigned to: "Manager Email"
            Title: "Invoice Approval: @{outputs('Parse_JSON')?['InvoiceNumber']}"
            Details: "Amount: $@{outputs('Parse_JSON')?['Amount']}"
            
        - action: "Condition - Approval"
          if_approved:
            - action: "Move file"
              Destination: "Approved"
            - action: "Send email"
              To: "Vendor Email"
              Subject: "Invoice Approved"
          if_rejected:
            - action: "Move file"
              Destination: "Rejected"
              
      # If Amount <= 10000
      if_no:
        - action: "Move file"
          Destination: "Approved"
        - action: "Send email"
          To: "Vendor Email"
          Subject: "Invoice Auto-Approved"

#!/usr/bin/env python3
"""Programmatic workflow automation."""

from dataclasses import dataclass
from typing import Dict, List
import json

@dataclass
class WorkflowStep:
    """Workflow step definition."""
    
    step_id: str
    action: str
    inputs: Dict
    conditions: List[Dict] = None

class WorkflowBuilder:
    """Build workflow programmatically."""
    
    def __init__(self, name: str):
        self.name = name
        self.steps: List[WorkflowStep] = []
        self.triggers = {}
    
    def add_trigger(self, trigger_type: str, config: Dict):
        """Add workflow trigger."""
        
        self.triggers = {
            'type': trigger_type,
            'config': config
        }
    
    def add_step(self, step: WorkflowStep):
        """Add workflow step."""
        
        self.steps.append(step)
    
    def add_condition(self, step: str, condition: Dict, 
                    yes_steps: List[WorkflowStep],
                    no_steps: List[WorkflowStep] = None):
        """Add conditional branching."""
        
        step_obj = self._find_step(step)
        
        if step_obj:
            step_obj.conditions = [
                {
                    'expression': condition.get('expression'),
                    'yes': [s.step_id for s in yes_steps],
                    'no': [s.step_id for s in (no_steps or [])]
                }
            ]
    
    def _find_step(self, step_id: str) -> WorkflowStep:
        """Find step by ID."""
        
        for step in self.steps:
            if step.step_id == step_id:
                return step
        return None
    
    def export_json(self) -> str:
        """Export workflow as JSON."""
        
        workflow = {
            'name': self.name,
            'trigger': self.triggers,
            'steps': [
                {
                    'id': s.step_id,
                    'action': s.action,
                    'inputs': s.inputs,
                    'conditions': s.conditions
                }
                for s in self.steps
            ]
        }
        
        return json.dumps(workflow, indent=2)

# Example: Build invoice workflow
def create_invoice_workflow() -> WorkflowBuilder:
    """Create invoice approval workflow."""
    
    workflow = WorkflowBuilder("Invoice Approval")
    
    workflow.add_trigger("file_created", {
        "location": "SharePoint/Invoices"
    })
    
    workflow.add_step(WorkflowStep(
        "get_file",
        "get_file_properties",
        {"site": "finance.sharepoint.com"}
    ))
    
    workflow.add_step(WorkflowStep(
        "extract_data",
        "ocr_extract",
        {"source": "file"}
    ))
    
    workflow.add_step(WorkflowStep(
        "check_amount",
        "condition",
        {"field": "amount", "operator": "gt", "value": 10000}
    ))
    
    workflow.add_step(WorkflowStep(
        "get_approval",
        "wait_approval",
        {"assignee": "manager", "timeout": "3d"}
    ))
    
    workflow.add_step(WorkflowStep(
        "process_approval",
        "process_result",
        {}
    ))
    
    return workflow

// Zapier/Make (Integromat) Integration

// Webhook Handler for External Events
const setupWebhookHandler = () => {
  // Catch hook from external system
  const incomingData = request.body;
  
  // Process and route
  if (incomingData.event === 'order.created') {
    // Create order in CRM
    return createOrderInCRM(incomingData);
  }
  
  if (incomingData.event === 'payment.received') {
    // Update invoice status
    return updateInvoiceStatus(incomingData);
  }
  
  return { status: 'processed' };
};

// Data Transformation
const transformData = (input, mapping) => {
  const output = {};
  
  mapping.forEach(field => {
    const sourceValue = getNestedValue(input, field.source);
    const transformedValue = applyTransform(
      sourceValue, 
      field.transform
    );
    setNestedValue(output, field.target, transformedValue);
  });
  
  return output;
};

// Aggregation Pattern
const aggregateOrders = (orders, windowMinutes = 60) => {
  const now = Date.now();
  const windowStart = now - windowMinutes * 60 * 1000;
  
  const recentOrders = orders.filter(o => 
    o.createdAt > windowStart
  );
  
  return {
    orderCount: recentOrders.length,
    totalValue: recentOrders.reduce((sum, o) => sum + o.value, 0),
    orders: recentOrders
  };
};

// Retry Logic
const executeWithRetry = async (fn, maxRetries = 3) => {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      return await fn();
    } catch (error) {
      if (attempt === maxRetries) throw error;
      
      // Exponential backoff
      await sleep(Math.pow(2, attempt) * 1000);
    }
  }
};

#!/usr/bin/env python3
"""RPA (Robotic Process Automation) with Python."""

from typing import Dict, List, Callable
import time
from dataclasses import dataclass
from enum import Enum

class ActionType(Enum):
    """RPA action types."""
    CLICK = "click"
    TYPE = "type"
    WAIT = "wait"
    EXTRACT = "extract"
    CONDITION = "condition"
    LOOP = "loop"

@dataclass
class RPAAction:
    """RPA action definition."""
    
    action_type: ActionType
    selector: str = None
    value: str = None
    wait_seconds: float = 0

class RPABot:
    """RPA bot for process automation."""
    
    def __init__(self, name: str):
        self.name = name
        self.actions: List[RPAAction] = []
        self.variables: Dict = {}
    
    def click(self, selector: str) -> 'RPABot':
        """Click action."""
        
        self.actions.append(RPAAction(ActionType.CLICK, selector))
        return self
    
    def type(self, selector: str, value: str) -> 'RPABot':
        """Type text action."""
        
        self.actions.append(RPAAction(
            ActionType.TYPE, selector, value
        ))
        return self
    
    def wait(self, seconds: float) -> 'RPABot':
        """Wait action."""
        
        self.actions.append(RPAAction(
            ActionType.WAIT, wait_seconds=seconds
        ))
        return self
    
    def extract(self, selector: str, variable_name: str) -> 'RPABot':
        """Extract data to variable."""
        
        action = RPAAction(ActionType.EXTRACT, selector)
        action.variable_name = variable_name
        self.actions.append(action)
        return self
    
    def condition(self, condition_fn: Callable, 
                 if_true: List[RPAAction],
                 if_false: List[RPAAction] = None) -> 'RPABot':
        """Conditional branching."""
        
        action = RPAAction(ActionType.CONDITION)
        action.condition = condition_fn
        action.if_true = if_true
        action.if_false = if_false or []
        self.actions.append(action)
        return self
    
    def loop(self, items: List, 
             body: List[RPAAction]) -> 'RPABot':
        """Loop over items."""
        
        action = RPAAction(ActionType.LOOP)
        action.items = items
        action.body = body
        self.actions.append(action)
        return self
    
    def execute(self):
        """Execute the RPA bot."""
        
        for action in self.actions:
            self._execute_action(action)
    
    def _execute_action(self, action: RPAAction):
        """Execute single action."""
        
        if action.action_type == ActionType.CLICK:
            # Use Playwright/Selenium
            print(f"Clicking: {action.selector}")
            
        elif action.action_type == ActionType.TYPE:
            print(f"Typing: {action.value} into {action.selector}")
            
        elif action.action_type == ActionType.WAIT:
            print(f"Waiting: {action.wait_seconds}s")
            time.sleep(action.wait_seconds)
            
        elif action.action_type == ActionType.EXTRACT:
            print(f"Extracting: {action.selector}")

# Example: Invoice Processing Bot
def create_invoice_bot() -> RPABot:
    """Create invoice processing RPA bot."""
    
    bot = RPABot("Invoice Processor")
    
    bot.click("a[href='/invoices/new']")
    bot.wait(2)
    bot.type("input#invoice_number", "{{invoice_number}}")
    bot.type("input#amount", "{{amount}}")
    bot.click("button[type='submit']")
    bot.wait(3)
    bot.extract("div.status", "invoice_status")
    
    # Conditional based on status
    def status_is_approved():
        return bot.variables.get('invoice_status') == 'Approved'
    
    bot.condition(
        status_is_approved,
        if_true=[
            bot.click("button[title='Process Payment']"),
            bot.wait(2)
        ],
        if_false=[
            bot.click("button[title='Request Info']")
        ]
    )
    
    return bot

# Platform Selection Matrix
platform_comparison:
  criteria:
    - name: "Ease of Use"
      weight: 0.2
    - name: "Integration Options"
      weight: 0.15
    - name: "Scalability"
      weight: 0.15
    - name: "Security"
      weight: 0.2
    - name: "Cost"
      weight: 0.15
    - name: "Support"
      weight: 0.15

  platforms:
    - name: "Power Automate"
      scores:
        ease_of_use: 9
        integrations: 8
        scalability: 7
        security: 9
        cost: 7
        support: 8
      best_for: "Microsoft ecosystem, enterprise"
      
    - name: "Zapier"
      scores:
        ease_of_use: 10
        integrations: 10
        scalability: 6
        security: 7
        cost: 6
        support: 7
      best_for: "SMB, startups, quick integrations"
      
    - name: "OutSystems"
      scores:
        ease_of_use: 7
        integrations: 8
        scalability: 9
        security: 9
        cost: 5
        support: 8
      best_for: "Complex enterprise applications"
      
    - name: "Mendix"
      scores:
        ease_of_use: 8
        integrations: 8
        scalability: 9
        security: 9
        cost: 6
        support: 8
      best_for: "Enterprise app development"
      
    - name: "Appian"
      scores:
        ease_of_use: 7
        integrations: 7
        scalability: 8
        security: 10
        cost: 5
        support: 8
      best_for: "Process automation, BPM"

# Enterprise LC/NC Governance Framework
governance:
  # Citizen Developer Program
  citizen_developers:
    enable: true
    training:
      required_courses:
        - "Platform Basics"
        - "Security Awareness"
        - "Data Handling"
      certification: true
    
    sandbox:
      enable: true
      isolation: "dedicated_environment"
      restrictions:
        - "No PII access"
        - "Limited API access"
        - "Test data only"
    
    production:
      requires_approval: true
      code_review: false
      security_review: true
      business_review: true
  
  # Security Controls
  security:
    authentication:
      - SSO_required: true
      - MFA_required: true
      - Session_timeout: 30_minutes
    
    authorization:
      - RBAC: true
      - Audit_logging: true
      - Data_classification: required
    
    data_protection:
      - encryption_at_rest: true
      - encryption_in_transit: true
      - PII_handling: "strict"
      - data_residency: "required"
  
  # Monitoring and Auditing
  monitoring:
    audit_log_retention: 7_years
    real_time_alerts:
      - "Failed authentications"
      - "Permission changes"
      - "Data exports"
    
    metrics:
      - "Active citizen developers"
      - "Apps in production"
      - "Automation usage"
      - "Cost tracking"