AI Automation for Small Business 2025: Step-by-Step Implementation Guide (Save 20+ Hours)

from typing import List, Dict
from dataclasses import dataclass

@dataclass
class BusinessTask:
    """Represents a business task for automation analysis."""
    name: str
    frequency_weekly: int
    minutes_per_instance: int
    complexity_score: int  # 1-10 (1=simple, 10=complex)
    error_prone: bool

def analyze_automation_opportunities(
    tasks: List[BusinessTask],
    automation_threshold: int = 100
) -> List[Dict[str, any]]:
    """
    Analyze and rank tasks by automation potential.

    Args:
        tasks: List of business tasks to evaluate
        automation_threshold: Minimum weekly minutes to consider

    Returns:
        Sorted list of tasks with automation scores
    """
    results = []

    for task in tasks:
        try:
            # Calculate time impact
            weekly_minutes = task.frequency_weekly * task.minutes_per_instance
            annual_hours = (weekly_minutes * 52) / 60

            # Calculate automation score (lower complexity = higher score)
            # Formula: (time_impact * error_factor) / complexity
            error_factor = 1.5 if task.error_prone else 1.0
            automation_score = (weekly_minutes * error_factor) / task.complexity_score

            if weekly_minutes >= automation_threshold:
                results.append({
                    'task': task.name,
                    'weekly_minutes': weekly_minutes,
                    'annual_hours': round(annual_hours, 1),
                    'automation_score': round(automation_score, 2),
                    'complexity': task.complexity_score,
                    'recommendation': 'High Priority' if automation_score > 50 else 'Medium Priority'
                })
        except Exception as e:
            print(f"Error analyzing {task.name}: {e}")
            continue

    # Sort by automation score (highest first)
    return sorted(results, key=lambda x: x['automation_score'], reverse=True)

# Example: Small e-commerce business
tasks = [
    BusinessTask('Order confirmation emails', 50, 5, 2, False),
    BusinessTask('Invoice generation', 20, 15, 3, True),
    BusinessTask('Customer support FAQs', 40, 10, 4, False),
    BusinessTask('Social media posting', 7, 20, 3, False),
    BusinessTask('Inventory tracking', 5, 45, 6, True),
    BusinessTask('Appointment scheduling', 30, 8, 2, False),
]

opportunities = analyze_automation_opportunities(tasks)

print("Top Automation Opportunities:")
print("-" * 70)
for idx, opp in enumerate(opportunities, 1):
    print(f"{idx}. {opp['task']}")
    print(f"   Weekly time: {opp['weekly_minutes']} min | Annual: {opp['annual_hours']} hrs")
    print(f"   Automation score: {opp['automation_score']} | {opp['recommendation']}")
    print()

# Output:
# Top Automation Opportunities:
# ----------------------------------------------------------------------
# 1. Order confirmation emails
#    Weekly time: 250 min | Annual: 216.7 hrs
#    Automation score: 125.0 | High Priority
#
# 2. Appointment scheduling
#    Weekly time: 240 min | Annual: 208.0 hrs
#    Automation score: 120.0 | High Priority
#
# 3. Invoice generation
#    Weekly time: 300 min | Annual: 260.0 hrs
#    Automation score: 150.0 | High Priority

from datetime import datetime
from typing import List, Dict

def calculate_automation_savings(
    automations: List[Dict[str, any]],
    implementation_hours: float,
    hourly_labor_cost: float
) -> Dict[str, float]:
    """
    Calculate time savings and ROI from automation implementation.

    Args:
        automations: List of automation configs with time savings
        implementation_hours: Total hours spent building automations
        hourly_labor_cost: Cost per labor hour ($)

    Returns:
        Dictionary with savings metrics
    """
    try:
        total_monthly_hours_saved = sum(
            a['weekly_hours_saved'] * 4.33 for a in automations
        )
        total_annual_hours_saved = total_monthly_hours_saved * 12

        # Calculate financial impact
        monthly_cost_savings = total_monthly_hours_saved * hourly_labor_cost
        annual_cost_savings = total_annual_hours_saved * hourly_labor_cost

        # Account for implementation cost
        implementation_cost = implementation_hours * hourly_labor_cost
        net_first_year_savings = annual_cost_savings - implementation_cost

        # Calculate payback period
        payback_months = implementation_cost / monthly_cost_savings if monthly_cost_savings > 0 else float('inf')

        return {
            'monthly_hours_saved': round(total_monthly_hours_saved, 1),
            'annual_hours_saved': round(total_annual_hours_saved, 0),
            'monthly_cost_savings': round(monthly_cost_savings, 2),
            'annual_cost_savings': round(annual_cost_savings, 2),
            'implementation_cost': round(implementation_cost, 2),
            'net_first_year_savings': round(net_first_year_savings, 2),
            'payback_months': round(payback_months, 2)
        }
    except Exception as e:
        print(f"Error calculating savings: {e}")
        return {}

# Example: Small marketing agency
automations = [
    {'name': 'Email templates', 'weekly_hours_saved': 4},
    {'name': 'Report generation', 'weekly_hours_saved': 6},
    {'name': 'Social media scheduling', 'weekly_hours_saved': 3},
    {'name': 'Invoice creation', 'weekly_hours_saved': 2},
    {'name': 'Client onboarding', 'weekly_hours_saved': 5}
]

savings = calculate_automation_savings(
    automations=automations,
    implementation_hours=40,
    hourly_labor_cost=35
)

print(f"Monthly hours saved: {savings['monthly_hours_saved']}")
print(f"Annual hours saved: {savings['annual_hours_saved']}")
print(f"Monthly cost savings: ${savings['monthly_cost_savings']}")
print(f"Annual cost savings: ${savings['annual_cost_savings']}")
print(f"Implementation cost: ${savings['implementation_cost']}")
print(f"Net first year savings: ${savings['net_first_year_savings']}")
print(f"Payback period: {savings['payback_months']} months")

# Output:
# Monthly hours saved: 86.6
# Annual hours saved: 1039.0
# Monthly cost savings: $3031.0
# Annual cost savings: $36365.0
# Implementation cost: $1400.0
# Net first year savings: $34965.0
# Payback period: 0.46 months

from dataclasses import dataclass
from typing import List, Dict
from datetime import datetime, timedelta

@dataclass
class AutomationMetric:
    """Monthly automation performance metrics."""
    month: str
    tasks_automated: int
    hours_saved: float
    errors: int
    cost: float

def build_roi_dashboard(
    metrics: List[AutomationMetric],
    baseline_monthly_cost: float,
    hourly_rate: float
) -> Dict[str, any]:
    """
    Generate comprehensive automation ROI dashboard.

    Args:
        metrics: Monthly performance data
        baseline_monthly_cost: Pre-automation labor cost
        hourly_rate: Labor cost per hour

    Returns:
        Dashboard metrics and trends
    """
    try:
        total_hours_saved = sum(m.hours_saved for m in metrics)
        total_cost = sum(m.cost for m in metrics)
        total_value = total_hours_saved * hourly_rate

        # Calculate monthly trend
        if len(metrics) >= 2:
            recent_avg = sum(m.hours_saved for m in metrics[-3:]) / min(3, len(metrics))
            early_avg = sum(m.hours_saved for m in metrics[:3]) / min(3, len(metrics))
            improvement_rate = ((recent_avg - early_avg) / early_avg * 100) if early_avg > 0 else 0
        else:
            improvement_rate = 0

        # Error rate
        total_tasks = sum(m.tasks_automated for m in metrics)
        total_errors = sum(m.errors for m in metrics)
        error_rate = (total_errors / total_tasks * 100) if total_tasks > 0 else 0

        # ROI calculation
        net_savings = total_value - total_cost
        roi_percentage = (net_savings / total_cost * 100) if total_cost > 0 else 0

        return {
            'total_hours_saved': round(total_hours_saved, 1),
            'total_value_generated': round(total_value, 2),
            'total_automation_cost': round(total_cost, 2),
            'net_savings': round(net_savings, 2),
            'roi_percentage': round(roi_percentage, 1),
            'error_rate': round(error_rate, 2),
            'improvement_trend': round(improvement_rate, 1),
            'cost_per_hour_saved': round(total_cost / total_hours_saved, 2) if total_hours_saved > 0 else 0
        }
    except Exception as e:
        print(f"Error building dashboard: {e}")
        return {}

# Example: 6 months of automation data
performance_data = [
    AutomationMetric('Jan 2025', 245, 18.5, 12, 150),
    AutomationMetric('Feb 2025', 312, 24.2, 8, 150),
    AutomationMetric('Mar 2025', 389, 31.4, 6, 150),
    AutomationMetric('Apr 2025', 445, 38.7, 4, 150),
    AutomationMetric('May 2025', 502, 44.3, 3, 150),
    AutomationMetric('Jun 2025', 534, 47.9, 2, 150),
]

dashboard = build_roi_dashboard(performance_data, 5000, 35)

print("Automation ROI Dashboard (6 Months)")
print("=" * 50)
print(f"Total hours saved: {dashboard['total_hours_saved']}")
print(f"Value generated: ${dashboard['total_value_generated']}")
print(f"Automation cost: ${dashboard['total_automation_cost']}")
print(f"Net savings: ${dashboard['net_savings']}")
print(f"ROI: {dashboard['roi_percentage']}%")
print(f"Error rate: {dashboard['error_rate']}%")
print(f"Improvement trend: +{dashboard['improvement_trend']}%")
print(f"Cost per hour saved: ${dashboard['cost_per_hour_saved']}")

# Output:
# Automation ROI Dashboard (6 Months)
# ==================================================
# Total hours saved: 205.0
# Value generated: $7175.0
# Automation cost: $900.0
# Net savings: $6275.0
# ROI: 697.2%
# Error rate: 1.5%
# Improvement trend: +131.2%
# Cost per hour saved: $4.39