Top 10 Custom Workflow and CRM Business Ideas for E-commerce Retailers to Scale to $10,000 Monthly Recurring Revenue (MRR)

1. AI-Powered Product Recommendation Engine with Dynamic Bundling

The core of scaling e-commerce MRR lies in increasing Average Order Value (AOV) and customer lifetime value (CLTV). A custom-built AI recommendation engine, integrated deeply with your CRM and order history, can achieve this by suggesting highly personalized product bundles. This goes beyond simple “customers who bought this also bought that.” We’re talking about predicting future needs based on browsing behavior, purchase frequency, and even external data points like weather or local events.

Technical Implementation:

• Data Ingestion: Real-time streaming of website events (page views, add-to-carts, searches) via Kafka or AWS Kinesis. Batch processing of historical order data from your database (e.g., PostgreSQL, MySQL).
• Feature Engineering: Create user embeddings (e.g., using Word2Vec on product sequences) and item embeddings. Incorporate demographic data, purchase history, and session data.
• Model Training: Employ collaborative filtering (e.g., ALS from Spark MLlib) or deep learning models (e.g., Recurrent Neural Networks like LSTMs for sequential recommendations, or Graph Neural Networks for complex relationships).
• API Endpoint: Expose recommendations via a RESTful API (e.g., Flask/FastAPI in Python) that your frontend can query.
• Dynamic Bundling Logic: Implement a rule engine that, based on recommendations, dynamically creates bundles with a slight discount (e.g., 5-10%) to incentivize purchase. This logic should also consider inventory levels and profit margins.

Example Python Snippet (Conceptual – Flask API):

from flask import Flask, request, jsonify
import pandas as pd
# Assume 'recommendation_model' is a pre-trained model object
# Assume 'product_data' is a DataFrame with product details (ID, price, margin)
# Assume 'user_history' is a DataFrame with user purchase history

app = Flask(__name__)

@app.route('/recommendations', methods=['GET'])
def get_recommendations():
    user_id = request.args.get('user_id')
    if not user_id:
        return jsonify({"error": "user_id is required"}), 400

    # 1. Get raw recommendations from the model
    raw_recs = recommendation_model.predict(user_id) # Returns list of product IDs

    # 2. Filter out already purchased items or out-of-stock items
    # (Logic to fetch purchased_items and stock_levels from DB/Cache)
    filtered_recs = [rec for rec in raw_recs if rec not in purchased_items and stock_levels.get(rec, 0) > 0]

    # 3. Dynamic Bundling Logic
    # This is a simplified example. Real logic would be more complex.
    if len(filtered_recs) >= 2:
        # Try to form a bundle of the top 2 recommended items
        bundle_items = filtered_recs[:2]
        bundle_price = calculate_bundle_price(bundle_items) # Function to apply discount
        return jsonify({
            "user_id": user_id,
            "recommendations": filtered_recs,
            "suggested_bundle": {
                "items": bundle_items,
                "price": bundle_price,
                "discount_percentage": 5 # Example
            }
        })
    else:
        return jsonify({
            "user_id": user_id,
            "recommendations": filtered_recs,
            "suggested_bundle": None
        })

def calculate_bundle_price(item_ids):
    # Fetch prices and apply discount
    total_price = sum(product_data.loc[pid, 'price'] for pid in item_ids)
    discounted_price = total_price * 0.95 # 5% discount
    return round(discounted_price, 2)

if __name__ == '__main__':
    app.run(debug=True, port=5000)

2. Predictive Customer Churn Prevention & Win-Back Campaigns

Retaining existing customers is significantly cheaper than acquiring new ones. Implementing a system to predict churn and proactively engage at-risk customers, or re-engage lapsed ones, is a direct path to MRR growth. This involves analyzing customer behavior patterns that precede churn.

Technical Implementation:

• Churn Indicators: Track metrics like decreasing purchase frequency, declining average order value, reduced website engagement (sessions, time on site), negative support interactions, and lack of response to marketing campaigns.
• Predictive Model: Use a classification model (e.g., Logistic Regression, Random Forest, Gradient Boosting) trained on historical data of churned vs. active customers. Features would include recency, frequency, monetary value (RFM), engagement metrics, and customer service interaction sentiment.
• Scoring & Segmentation: Assign a churn probability score to each active customer. Segment customers into risk tiers (e.g., High, Medium, Low Risk).
• Automated Workflows: Trigger personalized win-back campaigns via email, SMS, or push notifications based on churn score and segment. This could include special offers, personalized content, or surveys to gather feedback.
• CRM Integration: Log churn scores and campaign interactions directly into your CRM (e.g., HubSpot, Salesforce) for sales and support visibility.

Example SQL Query (Identifying potential churn indicators):

WITH CustomerActivity AS (
    SELECT
        customer_id,
        MAX(order_date) AS last_order_date,
        COUNT(DISTINCT order_id) AS total_orders,
        SUM(order_total) AS total_spent,
        MAX(order_date) - MIN(order_date) AS purchase_lifetime_days,
        AVG(JULIANDAY('now') - JULIANDAY(order_date)) AS avg_days_between_orders -- SQLite specific for days diff
    FROM orders
    WHERE order_date >= DATE('now', '-365 days') -- Consider activity in the last year
    GROUP BY customer_id
),
RecentActivity AS (
    SELECT
        customer_id,
        COUNT(session_id) AS recent_sessions,
        MAX(session_timestamp) AS last_session_timestamp
    FROM website_sessions
    WHERE session_timestamp >= DATE('now', '-30 days') -- Last 30 days
    GROUP BY customer_id
),
SupportInteractions AS (
    SELECT
        customer_id,
        COUNT(ticket_id) AS support_tickets_last_90d,
        AVG(CASE WHEN sentiment = 'negative' THEN 1 ELSE 0 END) AS negative_sentiment_ratio
    FROM support_tickets
    WHERE ticket_date >= DATE('now', '-90 days')
    GROUP BY customer_id
)
SELECT
    ca.customer_id,
    ca.last_order_date,
    ca.total_orders,
    ca.total_spent,
    ra.recent_sessions,
    si.support_tickets_last_90d,
    si.negative_sentiment_ratio,
    (JULIANDAY('now') - JULIANDAY(ca.last_order_date)) AS days_since_last_order,
    CASE
        WHEN (JULIANDAY('now') - JULIANDAY(ca.last_order_date)) > 90 AND ca.total_orders < 3 THEN 1 -- High churn risk: inactive & low order count
        WHEN (JULIANDAY('now') - JULIANDAY(ca.last_order_date)) > 180 THEN 1 -- High churn risk: very inactive
        WHEN si.negative_sentiment_ratio > 0.5 THEN 1 -- High churn risk: frequent negative support
        ELSE 0
    END AS predicted_churn_risk
FROM CustomerActivity ca
LEFT JOIN RecentActivity ra ON ca.customer_id = ra.customer_id
LEFT JOIN SupportInteractions si ON ca.customer_id = si.customer_id
WHERE ca.total_orders > 0 -- Only consider customers who have ordered at least once
ORDER BY predicted_churn_risk DESC, days_since_last_order DESC;

3. Automated Subscription Management & Upsell Flows

For businesses with recurring revenue models (e.g., consumables, digital products, services), optimizing subscription management is paramount. This includes reducing churn, automating dunning (failed payment recovery), and implementing intelligent upsell/cross-sell strategies within the subscription lifecycle.

Technical Implementation:

• Subscription Platform Integration: Leverage APIs of platforms like Stripe Billing, Chargebee, or Recurly. Build custom logic if using a homegrown solution.
• Dunning Automation: Configure automated email/SMS sequences for failed payments, including retry logic, grace periods, and clear instructions for updating payment methods.
• Subscription Analytics: Track key metrics like MRR, Churn Rate (Gross & Net), Customer Lifetime Value (CLTV), Average Revenue Per User (ARPU), and Expansion Revenue.
• Intelligent Upsell/Cross-sell: Based on subscription tier, usage patterns, or purchase history, trigger offers for higher tiers or complementary products/services. This can be done via email campaigns or in-app notifications.
• Pause/Skip Functionality: Allow customers to temporarily pause or skip a delivery/billing cycle, which can significantly reduce involuntary churn.

Example PHP Snippet (Conceptual – Stripe Webhook Handler for Payment Failure):

<?php
require 'vendor/autoload.php'; // Assuming Stripe PHP SDK is installed via Composer

// Set your secret key. Remember to switch to your live secret key in production.
// See https://dashboard.stripe.com/apikeys
\Stripe\Stripe::setApiKey('sk_test_YOUR_SECRET_KEY');

// Endpoint to receive Stripe webhooks
header('Content-Type: application/json');
$input = file_get_contents('php://input');
$event_json = json_decode($input, true);

// Verify the webhook signature (CRITICAL for security)
$signature = $_SERVER['HTTP_STRIPE_SIGNATURE'];
try {
    $event = \Stripe\Webhook::constructEvent(
        $input, $signature, 'whsec_YOUR_WEBHOOK_SECRET'
    );
} catch(\UnexpectedValueException $e) {
    // Invalid payload
    http_response_code(400);
    echo json_encode(['error' => 'Invalid payload']);
    exit();
} catch(\Stripe\Exception\SignatureVerificationException $e) {
    // Invalid signature
    http_response_code(400);
    echo json_encode(['error' => 'Invalid signature']);
    exit();
}

// Handle the event
switch ($event['type']) {
    case 'invoice.payment_failed':
        $invoice = $event['data']['object'];
        $subscription_id = $invoice['subscription'];
        $customer_id = $invoice['customer'];

        // Log the failure event
        error_log("Payment failed for subscription: {$subscription_id}, Customer: {$customer_id}");

        // Trigger dunning process (e.g., send email, schedule retry)
        // This would involve looking up customer contact info and initiating a campaign
        trigger_dunning_campaign($customer_id, $subscription_id, $invoice);

        break;
    // ... handle other event types
    default:
        // Unexpected event type
        error_log('Received unknown event type ' . $event['type']);
}

http_response_code(200);
echo json_encode(['status' => 'success']);

function trigger_dunning_campaign($customer_id, $subscription_id, $invoice_data) {
    // Placeholder: Implement your dunning logic here
    // - Fetch customer email/phone from your CRM/DB
    // - Send an email with payment instructions
    // - Schedule a follow-up retry via Stripe or your system
    $customer_email = get_customer_email($customer_id); // Your function to get email
    if ($customer_email) {
        $subject = "Action Required: Your Subscription Payment Failed";
        $message = "Dear Customer,\n\nWe were unable to process your recent subscription payment for subscription ID {$subscription_id}.\n\nPlease update your payment method here: [Link to update payment]\n\nIf you have already updated it, please disregard this message.\n\nThank you.";
        // mail($customer_email, $subject, $message); // Use a proper email sending service like SendGrid/Mailgun
        error_log("Dunning email triggered for {$customer_email}");
    }
}

function get_customer_email($customer_id) {
    // Placeholder: Query your database or CRM for the customer's email
    // Example: return $db->fetchOne("SELECT email FROM customers WHERE stripe_customer_id = ?", [$customer_id]);
    return '[email protected]'; // Replace with actual logic
}
?>

4. Dynamic Pricing & Inventory Management Integration

Optimizing pricing based on demand, seasonality, and competitor pricing, coupled with intelligent inventory forecasting, can significantly boost profit margins and reduce lost sales due to stockouts. This requires a system that can ingest market data and adjust prices dynamically while communicating stock levels to the front end.

Technical Implementation:

• Data Sources: Integrate with inventory management systems (e.g., NetSuite, SAP, custom ERP), sales data, website traffic analytics, and potentially external market data feeds (competitor pricing APIs, trend data).
• Pricing Algorithm: Develop algorithms that consider factors like:
  • Demand elasticity
  • Inventory levels (high stock = potential discount, low stock = potential price increase)
  • Seasonality and trends
  • Competitor pricing (if available)
  • Product lifecycle stage
• A/B Testing Framework: Implement a robust A/B testing system to validate pricing changes and measure their impact on conversion rates, AOV, and overall revenue.
• Real-time Price Updates: Ensure the pricing engine can update prices across all sales channels (website, marketplaces) with minimal latency. This often involves a caching layer and efficient database updates.
• Inventory Forecasting: Use time-series forecasting models (e.g., ARIMA, Prophet) on historical sales data to predict future demand and optimize reorder points.

Example Nginx Configuration Snippet (for caching product prices):

http {
    # ... other http configurations ...

    proxy_cache_path /var/cache/nginx/product_prices levels=1:2 keys_zone=product_price_cache:10m max_size=1g inactive=60m use_temp_path=off;

    server {
        listen 80;
        server_name your-ecommerce-domain.com;

        location /api/products/ {
            # Assuming your pricing API is served by a backend application
            proxy_pass http://your_backend_app_upstream;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;

            # Cache product price responses for 5 minutes
            proxy_cache product_price_cache;
            proxy_cache_valid 200 302 5m; # Cache successful responses for 5 minutes
            proxy_cache_valid 404 1m;    # Cache 404s for 1 minute
            proxy_cache_key "$scheme$request_method$host$request_uri";
            add_header X-Cache-Status $upstream_cache_status;

            # Bypass cache for POST/PUT/DELETE requests if applicable
            proxy_cache_bypass $http_pragma $http_authorization;
            proxy_no_cache $http_pragma $http_authorization;
        }

        # ... other location blocks for static assets, etc. ...
    }
}

5. Personalized Customer Journey Orchestration

Moving beyond generic email blasts, this involves mapping out and automating personalized customer journeys based on their behavior, preferences, and lifecycle stage. Each touchpoint should be relevant and timely, guiding the customer towards conversion or deeper engagement.

Technical Implementation:

• Customer Data Platform (CDP) or CRM: Centralize customer data from all touchpoints (website, email, social, support, purchases).
• Segmentation Engine: Define dynamic segments based on demographics, behavior (e.g., abandoned cart, viewed specific category, loyalty status), and purchase history.
• Journey Builder: Use a visual tool (e.g., HubSpot Workflows, Customer.io, Braze) or build custom logic to map out multi-step journeys.
• Triggering Mechanisms: Define triggers for journey entry and progression (e.g., user signs up, user adds item to cart but doesn’t purchase within 24 hours, user reaches VIP status).
• Channel Integration: Integrate with email marketing platforms, SMS gateways, push notification services, and potentially ad platforms for retargeting.
• Personalization Tokens: Utilize dynamic content (e.g., `{{first_name}}`, `{{last_purchased_item}}`, `{{recommended_product_image}}`) within communications.

Example JSON Payload (for a marketing automation system):

{
  "event": "abandoned_cart",
  "timestamp": "2023-10-27T10:30:00Z",
  "user": {
    "id": "user_12345",
    "email": "[email protected]",
    "first_name": "Jane",
    "last_name": "Doe",
    "segments": ["high_value", "interested_in_electronics"]
  },
  "data": {
    "cart_id": "cart_abcde",
    "items": [
      {
        "product_id": "prod_789",
        "name": "Wireless Noise-Cancelling Headphones",
        "price": 199.99,
        "quantity": 1,
        "image_url": "https://cdn.example.com/images/headphones.jpg",
        "url": "https://www.example.com/products/headphones"
      },
      {
        "product_id": "prod_101",
        "name": "Portable Bluetooth Speaker",
        "price": 79.99,
        "quantity": 1,
        "image_url": "https://cdn.example.com/images/speaker.jpg",
        "url": "https://www.example.com/products/speaker"
      }
    ],
    "total_value": 279.98
  },
  "journey_trigger": "abandoned_cart_email_sequence_v2"
}

6. Advanced Order Management & Fulfillment Automation

Streamlining the post-purchase experience is crucial for customer satisfaction and operational efficiency. Automating order processing, inventory allocation, and fulfillment workflows reduces errors, speeds up delivery, and frees up resources.

Technical Implementation:

• Order Management System (OMS): Integrate your e-commerce platform with a dedicated OMS or build robust internal logic.
• Inventory Allocation Rules: Implement rules for allocating stock based on fulfillment location (e.g., nearest warehouse), stock levels, and order priority.
• Warehouse Management System (WMS) Integration: Connect your OMS/e-commerce platform to your WMS (e.g., ShipStation, Manhattan Associates) for seamless picking, packing, and shipping.
• Automated Shipping Carrier Selection: Integrate with shipping APIs (e.g., Shippo, EasyPost) to automatically select the best carrier and service based on cost, speed, and destination.
• Real-time Order Status Tracking: Provide customers with real-time updates via email, SMS, or a customer portal, pulling data from your OMS and carrier APIs.
• Returns Management Automation: Automate the return initiation process, generate return labels, and track return status.

Example Bash Script (for triggering fulfillment based on new orders):

#!/bin/bash

# This script would typically be triggered by a webhook from your e-commerce platform
# or run as a cron job polling for new orders.

ORDER_API_ENDPOINT="https://api.yourecommercesite.com/v1/orders"
WMS_API_ENDPOINT="https://api.yourwms.com/v1/shipments"
AUTH_TOKEN="YOUR_API_TOKEN"

# Fetch new orders that haven't been processed yet
# (Assume a status field like 'fulfillment_status')
NEW_ORDERS=$(curl -s -X GET "$ORDER_API_ENDPOINT?status=unfulfilled&limit=50" \
     -H "Authorization: Bearer $AUTH_TOKEN")

# Check if any new orders were found
if [[ -z "$NEW_ORDERS" || "$(echo "$NEW_ORDERS" | jq '. | length')" -eq 0 ]]; then
    echo "No new unfulfilled orders found. Exiting."
    exit 0
fi

echo "Found $(echo "$NEW_ORDERS" | jq '. | length') new orders to process."

# Process each new order
echo "$NEW_ORDERS" | jq -c '.[]' | while read -r order; do
    ORDER_ID=$(echo "$order" | jq -r '.id')
    CUSTOMER_INFO=$(echo "$order" | jq '.customer')
    ITEMS=$(echo "$order" | jq '.items')
    SHIPPING_ADDRESS=$(echo "$order" | jq '.shipping_address')

    echo "Processing Order ID: $ORDER_ID"

    # 1. Allocate Inventory (Simplified - assumes WMS handles this based on shipment creation)
    # In a real system, you might check inventory availability here first.

    # 2. Prepare data for WMS API
    WMS_PAYLOAD=$(cat <



7. Customer Loyalty Program & VIP Tier Management



Rewarding loyal customers is a proven strategy for increasing retention and CLTV. A well-structured loyalty program, with clear tiers and benefits, encourages repeat purchases and higher spending.



Technical Implementation:



Points System: Define how customers earn points (e.g., per dollar spent, per purchase, for specific actions like reviews or social shares).
Tier Structure: Create distinct tiers (e.g., Bronze, Silver, Gold, Platinum) with increasing benefits (e.g., exclusive discounts, early access to sales, free shipping, birthday rewards). Define clear criteria for reaching and maintaining each tier (e.g., based on lifetime spend or points accumulated).
Reward Redemption: Allow customers to redeem points for discounts, exclusive products, or other rewards. Integrate this redemption process into the checkout flow.
CRM/Database Integration: Store customer points, tier status, and reward history. Use this data to personalize marketing communications and offers.
Automated Notifications: Send automated emails/SMS for point accrual, tier upgrades, reward availability, and tier status reminders.



Example SQL Schema Snippet (Loyalty Program Tables):



-- Table to store loyalty program configuration
CREATE TABLE loyalty_tiers (
    tier_id INT PRIMARY KEY AUTO_INCREMENT,
    tier_name VARCHAR(50) NOT NULL,
    min_points DECIMAL(10, 2) DEFAULT 0.00, -- Minimum points to reach this tier
    min_spend DECIMAL(10, 2) DEFAULT 0.00,  -- Minimum lifetime spend to reach this tier
    benefits TEXT, -- Description of benefits
    sort_order INT NOT NULL -- For ordering tiers display
);

-- Table to store customer loyalty status
CREATE TABLE customer_loyalty (
    customer_id INT PRIMARY KEY,
    current_points DECIMAL(10, 2) DEFAULT 0.00,
    lifetime_points DECIMAL(10, 2) DEFAULT 0.00,
    lifetime_spend DECIMAL(10, 2) DEFAULT 0.00,
    current_tier_id INT,
    last_tier_update TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (customer_id) REFERENCES customers(id),
    FOREIGN KEY (current_tier_id) REFERENCES loyalty_tiers(tier_id)
);

-- Table to log point transactions
CREATE TABLE point_transactions (
    transaction_id INT PRIMARY KEY AUTO_INCREMENT,
    customer_id INT NOT NULL,
    points_change DECIMAL(10, 2) NOT NULL, -- Positive for earning, negative for redemption
    transaction_type VARCHAR(50) NOT NULL, -- e.g., 'purchase', 'redemption', 'bonus', 'adjustment'
    order_id INT NULL, -- Link to order if applicable
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (customer_id) REFERENCES customers(id),
    FOREIGN KEY (order_id) REFERENCES orders(order_id)
);

-- Example data for loyalty_tiers
INSERT INTO loyalty_tiers (tier_name, min_points, min_spend, benefits, sort_order) VALUES
('Bronze', 0, 0.00, 'Basic rewards', 1),
('Silver', 500, 250.00, 'Free shipping on orders over $50', 2),
('Gold', 1500, 750.00, '10% off all orders, early access to sales', 3);




8. Automated Product Review & UGC Generation System



Social proof is incredibly powerful. Automating the process of requesting product reviews and user-generated content (UGC) after purchase can significantly boost conversion rates and build trust.



Technical Implementation:



Post-Purchase Email/SMS Sequence: Trigger automated requests for reviews a set number of days after order delivery.
Review Platform Integration: Integrate with review platforms like Trustpilot, Yotpo, or Bazaarvoice, or build your own review submission form.
Incentivization: Offer small incentives for submitting reviews (e.g., loyalty points, entry into a prize draw, a small discount on the next purchase).
UGC Campaigns: Run specific campaigns encouraging customers to share photos or videos of themselves using the product (e.g., using a specific hashtag on social media).
Content Curation & Display: Build tools to easily curate and display approved reviews and UGC on product pages, social media, and marketing materials.
Sentiment Analysis: Optionally, analyze review sentiment to identify product issues or areas for improvement.



Example Python Snippet (Postmark/SendGrid Email Trigger):



import requests
import json
from datetime import datetime, timedelta

# Assume 'orders' table has 'delivery_date' and 'customer_email'
# Assume 'products' table has 'name' and 'url'

def send_review_request_email(order_id, customer_email, order_items):
    """Sends an email requesting a product review."""

    api_key = "YOUR_EMAIL_API_KEY" # e.g., Postmark, SendGrid
    api_url = "https://api.postmarkapp.com/email" # Or SendGrid equivalent

    subject = "How do you like your new purchase?"
    html_body = f"
We'd love your feedback!
Thank you for your recent order ({order_id}). We hope you're enjoying your products.
"
    html_body += "
Please take a moment to review the items you purchased:
"

    for item in order_items:
        # Construct review link (e.g., to your review submission page)
        review_link = f"https://www.yourstore.com/reviews/submit?product_id={item['product_id']}&order_id={order_id}"
        html_body += f"
{item['product_name']}
"

    html_body += "
"
    html_body += "
As a thank you, you'll receive 50 loyalty points for each review submitted!
" # Incentive

    payload = {
        "From": "[email protected]",
        "To": customer_email,
        "Subject": subject,
        "HtmlBody": html_body,
        "TextBody": f"Subject: {subject}\n\nThank you for your recent order ({order_id})...\n\nReview items:\n" + "\n".join([f"- {item['product_name']}" for item in order_items]) + "\n\nEarn 50 loyalty points per review!"
    }

    headers = {
        "Accept": "application/json",
        "Content-Type": "application/json",
        "X-Postmark-Server-Token": api_key
    }

    try:
        response = requests.post(api_url, headers=headers, data=json.dumps(payload))
        response.raise_for_status() # Raise an exception for bad status codes
        print(f"Review request email sent successfully to {customer_email} for order {order_id}")
        return True
    except requests.exceptions.RequestException as e:
        print(f"Error sending review request email: {e}")
        return False

# --- Scheduler Logic (Conceptual) ---
def schedule_review_requests():
    # Fetch orders delivered in the last X days (e.g., 7 days)
    # This query needs to be optimized based on your DB schema
    # Example: SELECT order_id, customer_email, items FROM orders WHERE delivery_date BETWEEN ? AND ? AND review_request_sent = FALSE
    delivered_orders = get_delivered_orders(7) # Function to fetch orders

    for order in delivered_orders:
        # Fetch detailed item info if not already in the order object
        order_items_details = fetch_order_item_details(order['items']) # e.g., [{'product_id': '...', 'product_name': '...', 'url': '...'}]
        send_review_request_email(order['order_id'], order['customer_email'], order_items_details)
        # Mark order as review_request_sent = TRUE in DB

# Placeholder functions
def get_delivered_orders(days_ago):
    # Replace with actual DB query
    return [
        {'order_id': 'ORD1001', 'customer_email': '[email protected]', '