Top 50 Custom Workflow and CRM Business Ideas for E-commerce Retailers that Will Dominate the Software Industry in 2026

Automated Order Triage & Prioritization Engine

This system leverages machine learning to dynamically prioritize incoming orders based on a configurable set of criteria, such as customer lifetime value (CLV), order value, shipping urgency, inventory levels, and historical fulfillment performance. The goal is to optimize resource allocation and improve customer satisfaction for high-value or time-sensitive orders.

We can implement this using a Python-based microservice that integrates with your e-commerce platform’s API (e.g., Shopify, WooCommerce) and a PostgreSQL database for storing order data and ML model parameters. The core logic involves a scoring function that assigns a priority score to each order.

Core Components & Workflow

• Data Ingestion: Webhooks or scheduled API calls to fetch new orders.
• Feature Extraction: Calculate features like order value, items count, shipping distance, customer’s past purchase frequency, etc.
• ML Model Inference: A pre-trained model (e.g., XGBoost, LightGBM) predicts a “fulfillment risk” score or directly a “priority” score.
• Rule-Based Overrides: Apply business rules for manual adjustments (e.g., VIP customer flag, out-of-stock items).
• Output: Push prioritized order IDs to a message queue (e.g., RabbitMQ, Kafka) for downstream processing by fulfillment systems.

Example Python Implementation Snippet (Scoring Logic)

import pandas as pd
from sklearn.ensemble import RandomForestClassifier # Or any other suitable model

class OrderPrioritizer:
    def __init__(self, model_path, config):
        self.model = self._load_model(model_path)
        self.config = config

    def _load_model(self, model_path):
        # Load your pre-trained model (e.g., from a .pkl file)
        # For demonstration, we'll use a dummy model
        return RandomForestClassifier(n_estimators=10, random_state=42) # Dummy

    def calculate_priority_score(self, order_data):
        # order_data is a dictionary or DataFrame row
        features = self._extract_features(order_data)
        
        # Predict probability of high priority (or a direct score)
        # Assuming model predicts probability of 'high_priority' class (1)
        # In a real scenario, model would be trained on historical data
        # For this example, we'll simulate a score based on order value and customer tier
        
        score = 0
        order_value = order_data.get('total_price', 0)
        customer_tier = order_data.get('customer_tier', 'standard')

        score += order_value * self.config['value_weight']

        if customer_tier == 'vip':
            score += self.config['vip_bonus']
        elif customer_tier == 'premium':
            score += self.config['premium_bonus']

        # Add ML model prediction if available and trained
        # try:
        #     ml_prediction = self.model.predict_proba([features])[0][1] # Probability of class 1
        #     score += ml_prediction * self.config['ml_weight']
        # except Exception as e:
        #     print(f"ML prediction failed: {e}")
        #     # Fallback or log error

        # Apply business rules (e.g., urgent shipping)
        if order_data.get('shipping_method') == 'express':
            score += self.config['express_shipping_bonus']

        return max(0, score) # Ensure score is non-negative

    def _extract_features(self, order_data):
        # This method would contain logic to transform raw order_data
        # into features expected by the ML model.
        # Example features:
        # - order_value
        # - item_count
        # - customer_purchase_history_count
        # - days_since_last_purchase
        # - shipping_distance_km
        # - product_category_risk_score (e.g., high return rate categories)
        
        # For this dummy example, we'll just return a placeholder
        return [order_data.get('total_price', 0), order_data.get('item_count', 1)]

# --- Usage Example ---
if __name__ == "__main__":
    # Dummy model training (in a real scenario, this is done offline)
    # X_train = [[100, 2], [50, 1], [200, 3], [75, 2]] # Dummy features
    # y_train = [0, 0, 1, 0] # Dummy labels (0: low priority, 1: high priority)
    # dummy_model = RandomForestClassifier(n_estimators=10, random_state=42)
    # dummy_model.fit(X_train, y_train)
    # import joblib
    # joblib.dump(dummy_model, 'priority_model.pkl')

    # Configuration
    config = {
        'value_weight': 0.5,
        'vip_bonus': 50,
        'premium_bonus': 25,
        'express_shipping_bonus': 30,
        'ml_weight': 100 # Weight for ML model's probability score
    }

    prioritizer = OrderPrioritizer('priority_model.pkl', config) # Load actual model

    sample_orders = [
        {'order_id': 'ORD1001', 'total_price': 150.75, 'item_count': 3, 'customer_tier': 'standard', 'shipping_method': 'standard'},
        {'order_id': 'ORD1002', 'total_price': 75.00, 'item_count': 1, 'customer_tier': 'vip', 'shipping_method': 'express'},
        {'order_id': 'ORD1003', 'total_price': 300.50, 'item_count': 5, 'customer_tier': 'premium', 'shipping_method': 'standard'},
        {'order_id': 'ORD1004', 'total_price': 50.00, 'item_count': 2, 'customer_tier': 'standard', 'shipping_method': 'express'},
    ]

    prioritized_orders = []
    for order in sample_orders:
        score = prioritizer.calculate_priority_score(order)
        prioritized_orders.append({'order_id': order['order_id'], 'priority_score': score})

    # Sort by score in descending order
    prioritized_orders.sort(key=lambda x: x['priority_score'], reverse=True)

    print("Prioritized Orders:")
    for item in prioritized_orders:
        print(f"- Order ID: {item['order_id']}, Score: {item['priority_score']:.2f}")

AI-Powered Product Bundling & Upselling Engine

This system analyzes customer browsing history, purchase patterns, and product metadata to intelligently suggest product bundles and upsell opportunities in real-time. It moves beyond simple “frequently bought together” to sophisticated, context-aware recommendations that maximize Average Order Value (AOV).

Technical Architecture

A recommendation engine built using Python with libraries like Scikit-learn, TensorFlow/PyTorch, and potentially a graph database (e.g., Neo4j) for complex relationship modeling. It can be deployed as a microservice accessible via REST API.

Key Features & Data Sources

• Data Ingestion: User clickstream data (frontend tracking), order history (backend database), product catalog (PIM/CMS), customer segmentation data.
• Feature Engineering: User embeddings, product embeddings (using techniques like Word2Vec or FastText on product descriptions/attributes), co-occurrence matrices, collaborative filtering metrics.
• Recommendation Algorithms:
  • Content-based filtering (based on product attributes).
  • Collaborative filtering (user-item interactions).
  • Matrix factorization (SVD, NMF).
  • Deep learning models (e.g., Wide & Deep, Recurrent Neural Networks for sequential data).
  • Graph-based recommendations (if using Neo4j).
• Bundle Generation: Identify complementary products that, when bundled, offer a perceived value increase or solve a customer need more effectively. This can involve association rule mining (Apriori) or more advanced clustering techniques.
• Upsell Logic: Recommend higher-tier or premium versions of a product the user is currently viewing or has in their cart.
• Real-time API: A low-latency API endpoint that accepts user/product context and returns a list of recommended bundles or upsell items.

Example Python Snippet (Collaborative Filtering – User-Based)

import pandas as pd
from sklearn.metrics.pairwise import cosine_similarity
from scipy.sparse import csr_matrix

class UserBasedRecommender:
    def __init__(self, ratings_df, item_ids, user_ids):
        """
        ratings_df: DataFrame with columns ['user_id', 'item_id', 'rating']
        item_ids: List of all unique item IDs
        user_ids: List of all unique user IDs
        """
        self.ratings_df = ratings_df
        self.item_ids = item_ids
        self.user_ids = user_ids
        self.item_id_map = {id: i for i, id in enumerate(item_ids)}
        self.user_id_map = {id: i for i, id in enumerate(user_ids)}
        self.item_id_inv_map = {i: id for id, i in self.item_id_map.items()}
        self.user_id_inv_map = {i: id for id, i in self.user_id_map.items()}
        
        self.user_item_matrix = self._create_user_item_matrix()
        self.user_similarity_matrix = self._calculate_user_similarity()

    def _create_user_item_matrix(self):
        # Create a sparse matrix for efficiency
        n_users = len(self.user_ids)
        n_items = len(self.item_ids)
        
        row_indices = self.ratings_df['user_id'].map(self.user_id_map)
        col_indices = self.ratings_df['item_id'].map(self.item_id_map)
        ratings = self.ratings_df['rating'].values
        
        sparse_matrix = csr_matrix((ratings, (row_indices, col_indices)), shape=(n_users, n_items))
        return sparse_matrix

    def _calculate_user_similarity(self):
        # Using cosine similarity on the user-item matrix
        # Transpose to get item-user matrix, then calculate similarity between users
        user_similarity = cosine_similarity(self.user_item_matrix, dense_output=False)
        return user_similarity

    def get_recommendations(self, target_user_id, n_recommendations=5):
        if target_user_id not in self.user_id_map:
            return [] # User not found

        target_user_idx = self.user_id_map[target_user_id]
        
        # Get similarity scores for the target user with all other users
        user_similarities = self.user_similarity_matrix[target_user_idx].toarray().flatten()
        
        # Get indices of users sorted by similarity (descending)
        # Exclude the target user itself (similarity is 1)
        sorted_user_indices = user_similarities.argsort()[::-1]
        
        # Aggregate ratings from similar users for items the target user hasn't interacted with
        recommendation_scores = {}
        
        # Consider top K similar users (e.g., K=10 or 20)
        for i in range(1, min(20, len(sorted_user_indices))): # Start from 1 to skip self
            similar_user_idx = sorted_user_indices[i]
            similarity_weight = user_similarities[similar_user_idx]
            
            # Get items rated by this similar user
            similar_user_ratings = self.user_item_matrix[similar_user_idx]
            
            # Iterate through items rated by the similar user
            for item_idx in similar_user_ratings.indices:
                # Check if the target user has NOT rated this item
                if self.user_item_matrix[target_user_idx, item_idx] == 0:
                    item_id = self.user_id_inv_map[item_idx]
                    rating = similar_user_ratings[0, item_idx]
                    
                    # Weighted sum of ratings from similar users
                    if item_id not in recommendation_scores:
                        recommendation_scores[item_id] = 0
                    recommendation_scores[item_id] += similarity_weight * rating

        # Sort recommendations by score
        sorted_recommendations = sorted(recommendation_scores.items(), key=lambda item: item[1], reverse=True)
        
        # Return top N recommendations
        return sorted_recommendations[:n_recommendations]

# --- Usage Example ---
if __name__ == "__main__":
    # Sample data (replace with actual data loading)
    data = {
        'user_id': ['user1', 'user1', 'user2', 'user2', 'user2', 'user3', 'user3', 'user3', 'user4', 'user4'],
        'item_id': ['itemA', 'itemB', 'itemA', 'itemC', 'itemD', 'itemB', 'itemC', 'itemE', 'itemA', 'itemD'],
        'rating': [5, 4, 4, 5, 3, 5, 4, 5, 3, 4] # Ratings (e.g., 1-5)
    }
    ratings_df = pd.DataFrame(data)

    all_item_ids = list(ratings_df['item_id'].unique())
    all_user_ids = list(ratings_df['user_id'].unique())

    recommender = UserBasedRecommender(ratings_df, all_item_ids, all_user_ids)

    target_user = 'user1'
    recommendations = recommender.get_recommendations(target_user, n_recommendations=3)

    print(f"Recommendations for {target_user}:")
    if recommendations:
        for item_id, score in recommendations:
            print(f"- {item_id} (Score: {score:.2f})")
    else:
        print("No recommendations found.")

Dynamic Pricing & Inventory Optimization Module

This module uses predictive analytics to adjust product prices dynamically based on demand, competitor pricing, inventory levels, seasonality, and conversion rates. Simultaneously, it forecasts inventory needs to prevent stockouts and minimize overstocking.

System Design

A combination of Python microservices for ML modeling and a robust database (e.g., TimescaleDB for time-series data, Redis for caching dynamic prices) is recommended. Integration with ERP/inventory management systems and competitor price scraping tools is crucial.

Core Functionalities

• Demand Forecasting: ARIMA, Prophet, or LSTM models to predict future sales volumes.
• Competitor Price Monitoring: Web scraping (e.g., Scrapy, BeautifulSoup) to gather competitor pricing data.
• Price Elasticity Calculation: Analyze historical sales data to understand how price changes affect demand for specific products.
• Dynamic Pricing Algorithm: Implement algorithms (e.g., reinforcement learning, rule-based systems with optimization) to set optimal prices that balance revenue, profit margin, and market share.
• Inventory Level Monitoring: Real-time tracking of stock levels.
• Reorder Point Calculation: Based on demand forecasts and lead times.
• Overstock Alerts: Identify slow-moving inventory and suggest promotional pricing or liquidation strategies.

Example Python Snippet (Basic Demand Forecasting with Prophet)

import pandas as pd
from prophet import Prophet
import matplotlib.pyplot as plt

class DemandForecaster:
    def __init__(self, historical_sales_df):
        """
        historical_sales_df: DataFrame with columns ['ds' (datetime), 'y' (sales volume)]
        """
        self.df = historical_sales_df.rename(columns={'ds': 'ds', 'y': 'y'})
        self.model = Prophet()

    def train(self):
        # Add seasonality if relevant (e.g., weekly, yearly)
        # self.model.add_seasonality(name='yearly', period=365.25, fourier_order=10)
        # self.model.add_seasonality(name='weekly', period=7, fourier_order=3)
        self.model.fit(self.df)
        print("Demand forecasting model trained.")

    def predict(self, periods=30, freq='D'):
        """
        Predicts sales for the next 'periods' days.
        freq: 'D' for daily, 'W' for weekly, 'M' for monthly
        """
        future = self.model.make_future_dataframe(periods=periods, freq=freq)
        forecast = self.model.predict(future)
        return forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']]

    def plot_forecast(self, forecast_df):
        fig = self.model.plot(forecast_df)
        plt.title("Sales Demand Forecast")
        plt.show()
        
        fig2 = self.model.plot_components(forecast_df)
        plt.show()

# --- Usage Example ---
if __name__ == "__main__":
    # Generate sample historical sales data
    dates = pd.date_range(start='2023-01-01', periods=365, freq='D')
    # Simulate sales with some seasonality and trend
    sales = (100 + 
             50 * (dates.dayofweek < 5).astype(int) + # Higher sales on weekdays
             20 * (dates.month.isin([11, 12])).astype(int) + # Holiday boost
             10 * (dates.day % 7) + # Some random weekly pattern
             pd.np.random.normal(0, 15, len(dates))) # Noise
    sales = np.maximum(0, sales).astype(int) # Ensure non-negative sales

    historical_df = pd.DataFrame({'ds': dates, 'y': sales})

    forecaster = DemandForecaster(historical_df)
    forecaster.train()
    
    forecast_results = forecaster.predict(periods=90, freq='D') # Predict next 90 days

    print("\n--- Demand Forecast (Next 90 Days) ---")
    print(forecast_results.tail()) # Show last few predictions

    # Plotting the forecast (optional, for visualization)
    # forecaster.plot_forecast(forecast_results)

Customer Segmentation & Personalized Marketing Automation

This system moves beyond basic segmentation (e.g., demographics) to create dynamic, behavior-driven customer segments. It then automates personalized marketing campaigns across multiple channels (email, SMS, push notifications, social ads) based on these segments and individual customer journeys.

Architecture Overview

A data pipeline that aggregates customer data from various sources (CRM, e-commerce platform, analytics tools, support tickets). This data feeds into a segmentation engine (using clustering algorithms like K-Means or RFM analysis) and a marketing automation workflow engine. Tools like Apache Airflow for orchestration, a data warehouse (e.g., Snowflake, BigQuery), and integration with marketing platforms (e.g., Mailchimp API, Twilio API, Facebook Ads API) are key.

Key Components

• Data Integration Layer: ETL processes to consolidate data.
• Customer Profile Store: A unified view of each customer, including demographics, purchase history, engagement metrics, and segment assignments.
• Segmentation Engine:
  • RFM (Recency, Frequency, Monetary) analysis.
  • Behavioral segmentation (e.g., cart abandoners, frequent browsers, high-value purchasers).
  • Predictive segmentation (e.g., likely to churn, likely to purchase again).
• Marketing Automation Workflows: Visual workflow builder or code-based definition of triggers, actions, and campaign logic.
• Personalization Engine: Dynamically inserts personalized content (product recommendations, offers) into marketing messages.
• Channel Connectors: APIs to send messages via email, SMS, push, social ads.
• Performance Tracking & Analytics: Dashboards to monitor campaign performance, A/B test results, and ROI.

Example Python Snippet (RFM Segmentation)

import pandas as pd
import datetime as dt

class RFMSegmenter:
    def __init__(self, transactions_df, snapshot_date=None):
        """
        transactions_df: DataFrame with columns ['customer_id', 'order_date', 'order_total']
        snapshot_date: The date to calculate recency from. Defaults to the latest date in data + 1 day.
        """
        self.df = transactions_df
        if snapshot_date is None:
            self.snapshot_date = self.df['order_date'].max() + dt.timedelta(days=1)
        else:
            self.snapshot_date = snapshot_date
        
        self.df['order_date'] = pd.to_datetime(self.df['order_date'])

    def calculate_rfm(self):
        # Calculate RFM metrics
        rfm_data = self.df.groupby('customer_id').agg({
            'order_date': lambda x: (self.snapshot_date - x.max()).days, # Recency
            'order_id': 'count', # Frequency (assuming order_id is unique per order)
            'order_total': 'sum' # Monetary
        })
        
        # Rename columns for clarity
        rfm_data.rename(columns={'order_date': 'Recency', 
                                 'order_id': 'Frequency', 
                                 'order_total': 'Monetary'}, inplace=True)
        
        # Remove customers with 0 monetary value if they exist and are not relevant
        rfm_data = rfm_data[rfm_data['Monetary'] > 0]
        
        return rfm_data

    def assign_scores(self, rfm_data, quantiles=[0.25, 0.5, 0.75]):
        # Assign scores based on quantiles
        rfm_data['R_Score'] = pd.qcut(rfm_data['Recency'], q=quantiles, labels=False, duplicates='drop') + 1
        rfm_data['F_Score'] = pd.qcut(rfm_data['Frequency'], q=quantiles, labels=False, duplicates='drop') + 1
        rfm_data['M_Score'] = pd.qcut(rfm_data['Monetary'], q=quantiles, labels=False, duplicates='drop') + 1
        
        # Handle cases where qcut might drop labels due to identical values
        # Ensure scores are within expected range (e.g., 1 to num_quantiles+1)
        max_score = len(quantiles) + 1
        rfm_data['R_Score'] = rfm_data['R_Score'].astype(int).clip(1, max_score)
        rfm_data['F_Score'] = rfm_data['F_Score'].astype(int).clip(1, max_score)
        rfm_data['M_Score'] = rfm_data['M_Score'].astype(int).clip(1, max_score)

        return rfm_data

    def assign_segments(self, rfm_data):
        # Define segments based on RFM scores (example logic)
        rfm_data['RFM_Score'] = rfm_data['R_Score'].astype(str) + rfm_data['F_Score'].astype(str) + rfm_data['M_Score'].astype(str)
        
        # Example segment mapping (can be much more granular)
        segment_map = {
            # High Value Customers
            '444': 'Champions', '443': 'Loyal Customers', '434': 'Loyal Customers',
            '344': 'Loyal Customers', '433': 'Potential Loyalists', '343': 'Potential Loyalists',
            '334': 'Potential Loyalists',
            # Mid Value Customers
            '333': 'Average Customers', '233': 'Average Customers', '323': 'Average Customers',
            '332': 'Average Customers', '222': 'Average Customers',
            # Low Value / At Risk Customers
            '111': 'Lost Customers', '112': 'Lost Customers', '121': 'Lost Customers',
            '211': 'Lost Customers', '122': 'At Risk', '212': 'At Risk',
            '221': 'At Risk', '131': 'Needs Attention', '132': 'Needs Attention',
            '231': 'Needs Attention', '311': 'Needs Attention', '312': 'Needs Attention',
            '141': 'New Customers', '241': 'New Customers', '341': 'New Customers',
            '411': 'New Customers', '421': 'New Customers', '431': 'New Customers',
            '441': 'New Customers', '442': 'Potential Loyalists', '432': 'Potential Loyalists',
            '422': 'Potential Loyalists', '322': 'Average Customers', '223': 'Average Customers',
            '232': 'Average Customers', '321': 'Needs Attention', '213': 'At Risk',
            '123': 'At Risk', '133': 'Needs Attention', '234': 'Loyal Customers',
            '331': 'Needs Attention', '113': 'Lost Customers', '114': 'Lost Customers',
            '124': 'Lost Customers', '142': 'New Customers', '143': 'New Customers',
            '144': 'New Customers', '214': 'Lost Customers', '224': 'Loyal Customers',
            '242': 'Loyal Customers', '243': 'Loyal Customers', '244': 'Loyal Customers',
            '313': 'Needs Attention', '314': 'Needs Attention', '324': 'Loyal Customers',
            '342': 'Loyal Customers', '412': 'New Customers', '413': 'New Customers',
            '414': 'New Customers', '423': 'Loyal Customers', '424': 'Loyal Customers',
            '432': 'Potential Loyalists', '433': 'Loyal Customers', '434': 'Loyal Customers',
            '443': 'Loyal Customers', '444': 'Champions'
        }
        
        rfm_data['Segment'] = rfm_data['RFM_Score'].map(segment_map)
        
        # Fallback for any unmapped scores
        rfm_data['Segment'] = rfm_data['Segment'].fillna('Other')
        
        return rfm_data

# --- Usage Example ---
if __name__ == "__main__":
    # Sample transaction data
    data = {
        'customer_id': ['C1', 'C1', 'C2', 'C3', 'C2', 'C1', 'C4', 'C3', 'C2', 'C1', 'C5', 'C5'],
        'order_id': ['O1', 'O2', 'O3', 'O4', 'O5', 'O6', 'O7', 'O8', 'O9', 'O10', 'O11', 'O12'],
        'order_date': [
            '2023-10-01', '2023-11-15', '2023-09-20', '2023-10-05', '2023-11-01',
            '2023-12-01', '2023-12-10', '2023-11-20', '2023-12-15', '2023-12-20',
            '2023-12-18', '2023-12-22'
        ],
        'order_total': [100.50, 75.20, 200.00, 50.00, 150.75, 90.00, 30.00, 65.50, 180.00, 110.00, 45.00, 55.00]
    }
    transactions_df = pd.DataFrame(data)

    # Define snapshot date (e.g., today + 1 day)
    snapshot_date = dt.datetime(2023, 12, 25) 

    segmenter = RFMSegmenter(transactions_df, snapshot_date=snapshot_date)
    rfm_metrics = segmenter.calculate_rfm()
    rfm_scored = segmenter.assign_scores(rfm_metrics)
    rfm_segmented = segmenter.assign_segments(rfm_scored)

    print("--- RFM Segmentation Results ---")
    print(rfm_segmented[['Recency', 'Frequency', 'Monetary', 'R_Score', 'F_Score', 'M_Score', 'Segment']])

    # Example: Get segment for a specific customer
    customer_segment = rfm_segmented.loc['C1', 'Segment']
    print(f"\nSegment for Customer C1: {customer_segment}")

Automated Returns & Exchange Management System

Streamlines the entire returns and exchange process, from customer initiation to warehouse processing and refund/reshipment. This reduces manual effort, improves customer experience during a potentially negative interaction, and provides valuable data on product issues.

System Components & Workflow

• Customer Portal/Form: A self-service interface for customers to initiate returns/exchanges, select reasons, and generate return labels.
• Admin Dashboard: For managing return requests, approving/denying, tracking status, and processing refunds/exchanges.
• Warehouse Integration: API or file-based integration to notify the warehouse of incoming returns, track received items, and manage restocking or disposal.
• Automated Notifications: Email/SMS alerts to customers and internal teams at key stages (request submitted, approved, item received, refund processed).
• Reason Code Analysis: Collect and analyze return reasons to identify product quality issues, sizing problems, or description inaccuracies.
• RMA Generation: Automated generation of Return Merchandise Authorization numbers.

Example PHP Snippet (Return Request Submission - Backend API Endpoint)

<?php

header('Content-Type: application/json');

// --- Database Configuration ---
$db_host = 'localhost';
$db_name = 'ecommerce_db';
$db_user = 'db_user';
$db_pass = 'db_password';

// --- Connection ---
try {
    $pdo = new PDO("mysql:host=$db_host;dbname=$db_name;charset=utf8", $db_user, $db_pass);
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
} catch (PDOException $e) {
    echo json_encode(['status' => 'error', 'message' => 'Database connection failed: ' . $e->getMessage()]);
    exit;
}

// --- Input Validation ---
$input = json_decode(file_get_contents('php://input'), true);

if (!$input) {
    echo json_encode(['status' => 'error', 'message' => 'Invalid JSON received.']);
    exit;
}

$required_fields = ['order_id', 'customer_id', 'product_ids', 'reason_code', 'return_type']; // 'return_type' can be 'return' or 'exchange'
foreach ($required_fields as $field) {
    if (!isset($input[$field]) || empty(trim($input[$field]))) {
        echo json_encode(['status' => 'error', 'message' => "Missing or empty required field: {$field}"]);
        exit;
    }
}

$order_id = filter_var($input['order_id'], FILTER_