Python Business Automation: Real Examples for SMEs

Why Python Dominates Business Automation for SMEs

According to Salesforce (2024), intelligent automation can reduce invoice data entry time by up to 70%. For SMEs facing resource constraints, Python offers unmatched flexibility, zero licensing costs, and a massive ecosystem of business-ready libraries. The business case is compelling:

• 50% reduction in time spent on repetitive tasks, according to MarketLiftUp (2024)
• +13 percentage points average conversion increase through automated quote follow-ups (Qonto Barometer, 2024)
• Potential 30% savings in administrative time by 2030 (McKinsey)

A French service SME reduced HR onboarding time by 2 hours per employee through Python automation (Oxelea case study, 2024). The initial investment typically amounts to a few days of development with measurable ROI within the first month.

"Python automation enables SMEs to compete with enterprise-level operational efficiency without enterprise-level IT budgets."

At Keerok, our Python automation expertise has helped dozens of SMEs transform their operations through strategic automation implementations.

Script 1: Automated Customer Payment Reminders

Chasing overdue invoices consumes significant accounting team time. This Python script analyzes your invoice file and sends personalized reminders automatically.

Python Code for Automated Reminders

import pandas as pd
import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from datetime import datetime, timedelta

# Load invoices from Excel
df = pd.read_excel('invoices.xlsx')

# Filter invoices overdue by more than 30 days
today = datetime.now()
df['invoice_date'] = pd.to_datetime(df['invoice_date'])
df['days_overdue'] = (today - df['invoice_date']).dt.days
overdue_invoices = df[df['days_overdue'] > 30]

# SMTP configuration
smtp_server = "smtp.gmail.com"
smtp_port = 587
sender_email = "accounts@yourcompany.com"
password = "your_app_password"

for index, invoice in overdue_invoices.iterrows():
    msg = MIMEMultipart()
    msg['From'] = sender_email
    msg['To'] = invoice['customer_email']
    msg['Subject'] = f"Payment Reminder - Invoice {invoice['invoice_number']}"
    
    body = f"""Dear {invoice['customer_name']},
    
    We notice that invoice #{invoice['invoice_number']} 
    for ${invoice['amount']}, issued on {invoice['invoice_date'].strftime('%m/%d/%Y')}, 
    remains outstanding.
    
    Please arrange payment at your earliest convenience.
    
    Best regards,
    Your Accounts Team
    """
    
    msg.attach(MIMEText(body, 'plain'))
    
    with smtplib.SMTP(smtp_server, smtp_port) as server:
        server.starttls()
        server.login(sender_email, password)
        server.send_message(msg)
    
    print(f"Reminder sent to {invoice['customer_name']}")

Measured Business Impact

According to the Qonto Barometer (2024), automated reminders generate +13 percentage points average conversion increase. A 20-employee SME typically saves:

• 4-6 hours per week in manual reminder processing
• 25% reduction in average payment delay
• 15% cash flow improvement through systematic follow-ups

For production deployment with OAuth2 and error handling, get in touch with our team for an audit of your invoicing processes.

Script 2: Automated Excel Data Extraction and Processing

Data analysts often lose 50% of their time on repetitive tasks, according to MarketLiftUp (2024). This script automatically consolidates multiple Excel files into a single report.

Multi-File Consolidation Code

import pandas as pd
import glob
import os
from datetime import datetime

# Define folder containing Excel files
source_folder = "./monthly_reports/"
files = glob.glob(os.path.join(source_folder, "*.xlsx"))

# List to store DataFrames
df_list = []

for file in files:
    # Extract month from filename
    filename = os.path.basename(file)
    month = filename.split('_')[1].split('.')[0]
    
    # Read Excel file
    df = pd.read_excel(file)
    df['month'] = month
    df['source_file'] = filename
    
    df_list.append(df)

# Consolidate all DataFrames
df_consolidated = pd.concat(df_list, ignore_index=True)

# Analytical calculations
df_consolidated['total_revenue'] = df_consolidated['quantity'] * df_consolidated['unit_price']

# Create pivot report
pivot_report = df_consolidated.pivot_table(
    index='product_category',
    columns='month',
    values='total_revenue',
    aggfunc='sum',
    fill_value=0
)

# Add totals
pivot_report['TOTAL'] = pivot_report.sum(axis=1)
pivot_report.loc['TOTAL'] = pivot_report.sum()

# Export consolidated report
export_date = datetime.now().strftime('%Y%m%d')
pivot_report.to_excel(f'consolidated_report_{export_date}.xlsx')

print(f"Consolidated report created: {len(files)} files processed")
print(f"Total revenue period: ${pivot_report.loc['TOTAL', 'TOTAL']:.2f}")

Real-World SME Use Case

An industrial SME automated purchase order information extraction, reducing processing time from several hours of manual work to seconds (documented by Oxelea, 2024). Benefits include:

• 95% elimination of manual data entry errors
• Automatic generation of weekly dashboards
• Capacity to process 10x more data without additional hiring

"Python transforms hours of Excel copy-paste into 30 seconds of automated execution, freeing our teams for strategic analysis."

Script 3: API Integration for CRM-Accounting Synchronization

API integration is crucial to avoid double data entry. This script automatically synchronizes customers between your CRM and accounting software.

Example with Stripe and QuickBooks APIs

import requests
import json
from datetime import datetime

# Stripe API configuration
STRIPE_API_KEY = "sk_test_your_key"
stripe_headers = {
    "Authorization": f"Bearer {STRIPE_API_KEY}"
}

# QuickBooks API configuration
QUICKBOOKS_TOKEN = "your_oauth_token"
QUICKBOOKS_COMPANY_ID = "your_company_id"
qb_headers = {
    "Authorization": f"Bearer {QUICKBOOKS_TOKEN}",
    "Content-Type": "application/json"
}

def fetch_stripe_customers():
    url = "https://api.stripe.com/v1/customers"
    response = requests.get(url, headers=stripe_headers)
    return response.json()['data']

def create_quickbooks_customer(stripe_customer):
    url = f"https://quickbooks.api.intuit.com/v3/company/{QUICKBOOKS_COMPANY_ID}/customer"
    
    customer_data = {
        "DisplayName": stripe_customer['name'],
        "PrimaryEmailAddr": {"Address": stripe_customer['email']},
        "Notes": f"Imported from Stripe - ID: {stripe_customer['id']}"
    }
    
    response = requests.post(url, headers=qb_headers, json=customer_data)
    return response.json()

def check_customer_exists(email, qb_customers):
    return any(c.get('PrimaryEmailAddr', {}).get('Address') == email for c in qb_customers)

# Fetch existing QuickBooks customers
qb_query_url = f"https://quickbooks.api.intuit.com/v3/company/{QUICKBOOKS_COMPANY_ID}/query?query=SELECT * FROM Customer"
qb_response = requests.get(qb_query_url, headers=qb_headers)
qb_customers = qb_response.json().get('QueryResponse', {}).get('Customer', [])

# Synchronize customers
stripe_customers = fetch_stripe_customers()
customers_created = 0

for customer in stripe_customers:
    if not check_customer_exists(customer['email'], qb_customers):
        try:
            create_quickbooks_customer(customer)
            customers_created += 1
            print(f"Customer created: {customer['name']}")
        except Exception as e:
            print(f"Error for {customer['name']}: {str(e)}")

print(f"Synchronization complete: {customers_created} new customers added")

API Integration ROI

According to Salesforce (2024), automation can reduce up to 70% of accounting data entry time for supplier invoices. Python API integrations enable:

• Real-time synchronization between systems (CRM, accounting, e-commerce)
• Elimination of double data entry and associated errors
• Complete traceability of data flows between applications

Our custom Python automation solutions integrate the APIs of your existing tools to create a cohesive digital ecosystem.

Script 4: Automated PDF Report Generation

Manual PDF report creation consumes hours each week. This script automatically generates professional reports from your data.

from reportlab.lib.pagesizes import A4
from reportlab.lib import colors
from reportlab.lib.styles import getSampleStyleSheet
from reportlab.platypus import SimpleDocTemplate, Table, TableStyle, Paragraph, Spacer
import pandas as pd
from datetime import datetime

def generate_sales_report(data_file, output_file):
    # Load data
    df = pd.read_excel(data_file)
    
    # Create PDF document
    doc = SimpleDocTemplate(output_file, pagesize=A4)
    elements = []
    styles = getSampleStyleSheet()
    
    # Title
    title = Paragraph(
        f"Sales Report - {datetime.now().strftime('%B %Y')}",
        styles['Title']
    )
    elements.append(title)
    elements.append(Spacer(1, 20))
    
    # Executive summary
    total_revenue = df['amount'].sum()
    num_sales = len(df)
    avg_basket = total_revenue / num_sales
    
    summary = Paragraph(f"""
        Executive Summary:

        Total Revenue: ${total_revenue:,.2f}

        Number of Sales: {num_sales}

        Average Basket: ${avg_basket:,.2f}
    """, styles['Normal'])
    elements.append(summary)
    elements.append(Spacer(1, 20))
    
    # Sales by category table
    category_sales = df.groupby('category')['amount'].agg(['sum', 'count', 'mean']).reset_index()
    category_sales.columns = ['Category', 'Total Revenue', 'Num Sales', 'Avg Basket']
    
    # Convert to list for ReportLab
    data = [category_sales.columns.tolist()] + category_sales.values.tolist()
    
    table = Table(data)
    table.setStyle(TableStyle([
        ('BACKGROUND', (0, 0), (-1, 0), colors.grey),
        ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
        ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
        ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
        ('FONTSIZE', (0, 0), (-1, 0), 12),
        ('BOTTOMPADDING', (0, 0), (-1, 0), 12),
        ('BACKGROUND', (0, 1), (-1, -1), colors.beige),
        ('GRID', (0, 0), (-1, -1), 1, colors.black)
    ]))
    
    elements.append(table)
    
    # Generate PDF
    doc.build(elements)
    print(f"PDF report generated: {output_file}")

# Usage
generate_sales_report('sales_january.xlsx', 'sales_report_january.pdf')

Measured Time Savings

SMEs using this type of automation report:

• 80% reduction in report creation time
• Format standardization for better consistency
• Ability to generate daily reports without additional workload

Script 5: Web Scraping for Competitive Intelligence

Manual competitive intelligence is time-consuming. This script automatically monitors your competitors' pricing.

import requests
from bs4 import BeautifulSoup
import pandas as pd
from datetime import datetime
import time

def scrape_competitor_price(url, price_selector, name_selector):
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
    }
    
    try:
        response = requests.get(url, headers=headers)
        soup = BeautifulSoup(response.content, 'html.parser')
        
        product_name = soup.select_one(name_selector).text.strip()
        price_text = soup.select_one(price_selector).text.strip()
        price = float(price_text.replace('$', '').replace(',', '').strip())
        
        return {
            'product': product_name,
            'price': price,
            'url': url,
            'scrape_date': datetime.now()
        }
    except Exception as e:
        print(f"Scraping error {url}: {str(e)}")
        return None

# List of competitor URLs
competitors = [
    {'url': 'https://competitor1.com/product-a', 'price_selector': '.price', 'name_selector': '.product-name'},
    {'url': 'https://competitor2.com/product-a', 'price_selector': '.sale-price', 'name_selector': 'h1.title'}
]

# Scrape all competitors
results = []
for competitor in competitors:
    result = scrape_competitor_price(
        competitor['url'],
        competitor['price_selector'],
        competitor['name_selector']
    )
    if result:
        results.append(result)
    time.sleep(2)  # Pause to avoid overloading servers

# Save to Excel with history
df_new = pd.DataFrame(results)

try:
    df_history = pd.read_excel('price_monitoring.xlsx')
    df_final = pd.concat([df_history, df_new], ignore_index=True)
except FileNotFoundError:
    df_final = df_new

df_final.to_excel('price_monitoring.xlsx', index=False)
print(f"Monitoring complete: {len(results)} prices updated")

Strategic Advantages

• 24/7 competitor price monitoring
• Automatic alerts on price changes
• Complete history for trend analysis

Scripts 6 & 7: HR Automation and Document Management

Script 6: Automated Employee Onboarding

Inspired by the Oxelea (2024) case study that reduced HR setup time by 2 hours per employee, this script automates account creation and welcome document distribution.

import os
import shutil
from email.mime.multipart import MIMEMultipart
from email.mime.base import MIMEBase
from email.mime.text import MIMEText
from email import encoders
import smtplib

def onboard_employee(first_name, last_name, email, position, start_date):
    # Create personal folder
    employee_folder = f"./employees/{last_name}_{first_name}"
    os.makedirs(employee_folder, exist_ok=True)
    
    # Copy template documents
    templates = ['contract_template.docx', 'employee_handbook.pdf', 'onboarding_guide.pdf']
    for template in templates:
        shutil.copy(f"./templates/{template}", employee_folder)
    
    # Generate welcome email
    msg = MIMEMultipart()
    msg['Subject'] = f"Welcome to [Company] - {position}"
    
    body = f"""Dear {first_name},
    
    Welcome to the team! Your start date is {start_date}.
    
    Please find attached all necessary documents.
    
    Looking forward to working with you,
    The HR Team
    """
    
    msg.attach(MIMEText(body, 'plain'))
    
    # Attach documents
    for file in os.listdir(employee_folder):
        path = os.path.join(employee_folder, file)
        with open(path, 'rb') as f:
            part = MIMEBase('application', 'octet-stream')
            part.set_payload(f.read())
            encoders.encode_base64(part)
            part.add_header('Content-Disposition', f'attachment; filename={file}')
            msg.attach(part)
    
    # Send email (SMTP configuration similar to previous examples)
    print(f"Onboarding prepared for {first_name} {last_name}")
    
    return employee_folder

Script 7: Automated Document Classification

import os
import shutil
from datetime import datetime
import re

def classify_document(file):
    filename = os.path.basename(file).lower()
    
    # Classification rules
    rules = {
        'invoices': ['invoice', 'bill', 'receipt'],
        'contracts': ['contract', 'agreement', 'terms'],
        'quotes': ['quote', 'quotation', 'estimate'],
        'reports': ['report', 'summary', 'analysis']
    }
    
    for category, keywords in rules.items():
        if any(keyword in filename for keyword in keywords):
            return category
    
    return 'other'

def organize_documents(source_folder):
    # Create destination folders
    categories = ['invoices', 'contracts', 'quotes', 'reports', 'other']
    for cat in categories:
        os.makedirs(f"./archives/{cat}", exist_ok=True)
    
    files_processed = 0
    
    for file in os.listdir(source_folder):
        if file.endswith(('.pdf', '.docx', '.xlsx')):
            source_path = os.path.join(source_folder, file)
            category = classify_document(file)
            
            # Add date to filename
            date_str = datetime.now().strftime('%Y%m%d')
            new_name = f"{date_str}_{file}"
            dest_path = os.path.join(f"./archives/{category}", new_name)
            
            shutil.move(source_path, dest_path)
            files_processed += 1
            print(f"{file} → {category}/")
    
    print(f"Classification complete: {files_processed} documents organized")

# Usage
organize_documents('./downloads')

Production Deployment: Best Practices for SMEs

To deploy these scripts in production reliably, follow these recommendations:

1. Error Handling and Logging

• Use the logging module to trace all operations
• Implement try/except blocks to handle API errors gracefully
• Configure email alerts for critical failures

2. Data Security

• Store credentials in environment variables (never in code)
• Use OAuth2 rather than hardcoded passwords
• Encrypt sensitive data before storage

3. Scheduling and Monitoring

• Use cron (Linux) or Task Scheduler (Windows) for automatic execution
• Set up a monitoring dashboard (e.g., with Grafana)
• Test in a staging environment before production

4. Documentation and Maintenance

• Document each script with docstrings
• Create a README with installation instructions
• Version your code with Git

"Well-documented and maintained Python automation can run intervention-free for years, permanently freeing your teams from repetitive tasks."

The Future of Python Automation for SMEs

According to 2024-2026 trends identified by McKinsey and Mink Agency, Python automation is evolving toward:

• Increasing AI integration for data extraction, classification, and actionable insight generation
• Hybrid workflows combining Python with no-code tools like Zapier for greater flexibility
• RPA (Robotic Process Automation) accessible to SMEs through Python frameworks like Robot Framework
• Real-time analysis and orchestration of complex multi-system processes

SMEs investing in Python automation today are positioning themselves to save up to 30% of administrative time by 2030 (McKinsey), while improving process quality and traceability.

Conclusion: Where to Start Your Python Transformation

Python automation is no longer reserved for large enterprises. The 7 scripts presented in this article offer a concrete starting point for any SME looking to gain efficiency:

1. Start small: choose ONE repetitive process consuming 2-3 hours per week
2. Test a simple script (e.g., Excel consolidation or email reminders)
3. Measure ROI: time saved, errors reduced, team satisfaction
4. Iterate and expand: once the first script is in production, identify the next process to automate
5. Train your teams: Python autonomy is a strategic investment

At Keerok, we help SMEs transform their operations through Python automation. Our experts can audit your processes, develop custom scripts, and train your teams for sustainable autonomy.

Get in touch with our team for a free diagnostic of your automation opportunities. Together, let's identify the processes that will save you 10, 20, or 50 hours per month starting in the coming weeks.