Top 10 E-commerce Micro-Business Monetization Playbooks to Explode Profits that Will Dominate the Software Industry in 2026

1. Dynamic Pricing Engine with Real-time Inventory Scarcity Signals

Leveraging real-time inventory levels and demand signals to dynamically adjust pricing is a cornerstone of modern e-commerce profit maximization. This isn’t about simple A/B testing; it’s about an automated, data-driven system that reacts to market conditions instantaneously. We’ll implement a basic Python-based microservice that integrates with a hypothetical inventory API and a pricing database.

The core idea is to identify products with low stock and high recent sales velocity. These products are prime candidates for price increases. Conversely, products with high stock and low velocity might warrant a slight decrease to stimulate sales and free up capital.

Inventory and Pricing Data Model (Conceptual)

Assume we have two primary data sources:

• Inventory API: Returns JSON like {"product_id": "SKU123", "stock_level": 15, "last_updated": "2023-10-27T10:00:00Z"}
• Pricing Database (e.g., PostgreSQL): Stores current base price, historical price changes, and potentially a “demand score”. Schema might look like: CREATE TABLE product_pricing ( product_id VARCHAR(50) PRIMARY KEY, base_price DECIMAL(10, 2), current_price DECIMAL(10, 2), demand_score INT DEFAULT 0, last_price_update TIMESTAMP );

Python Microservice Implementation (Flask)

This service will poll the inventory API, analyze stock levels, and update prices in the database. We’ll use a simple Flask app for demonstration.

from flask import Flask, jsonify, request
import requests
import psycopg2
import os
from datetime import datetime, timedelta

app = Flask(__name__)

# Database Configuration
DB_HOST = os.environ.get("DB_HOST", "localhost")
DB_NAME = os.environ.get("DB_NAME", "ecommerce")
DB_USER = os.environ.get("DB_USER", "user")
DB_PASSWORD = os.environ.get("DB_PASSWORD", "password")

# Inventory API Configuration
INVENTORY_API_URL = os.environ.get("INVENTORY_API_URL", "http://inventory-service:5000/inventory") # Assuming a separate inventory service

# Pricing Adjustment Parameters
LOW_STOCK_THRESHOLD = 20
HIGH_STOCK_THRESHOLD = 100
DEMAND_SCORE_MULTIPLIER = 0.05 # 5% price increase per demand score point
PRICE_ADJUSTMENT_LIMIT_PERCENT = 0.15 # Max 15% price change per adjustment

def get_db_connection():
    conn = psycopg2.connect(host=DB_HOST, database=DB_NAME, user=DB_USER, password=DB_PASSWORD)
    return conn

@app.route('/adjust_prices', methods=['POST'])
def adjust_prices():
    try:
        conn = get_db_connection()
        cur = conn.cursor()

        # Fetch all products from our pricing table
        cur.execute("SELECT product_id, base_price, current_price, demand_score FROM product_pricing")
        products = cur.fetchall()

        updated_count = 0
        for product_id, base_price, current_price, demand_score in products:
            # 1. Get current inventory
            inventory_response = requests.get(f"{INVENTORY_API_URL}/{product_id}")
            if inventory_response.status_code != 200:
                app.logger.warning(f"Could not fetch inventory for {product_id}. Skipping.")
                continue
            inventory_data = inventory_response.json()
            stock_level = inventory_data.get("stock_level", 0)

            # 2. Calculate potential price adjustment
            new_price = current_price
            adjustment_reason = ""

            if stock_level < LOW_STOCK_THRESHOLD:
                # Increase price due to low stock and existing demand
                demand_driven_increase = base_price * DEMAND_SCORE_MULTIPLIER * demand_score
                potential_new_price = current_price + demand_driven_increase
                adjustment_reason = f"Low stock ({stock_level})"
            elif stock_level > HIGH_STOCK_THRESHOLD:
                # Potentially decrease price if stock is very high and demand is low
                # This logic would be more complex, involving sales velocity and time in stock
                # For simplicity, we'll just note it. A real system would have more sophisticated logic.
                app.logger.info(f"High stock ({stock_level}) for {product_id}. Consider price adjustment if demand is low.")
                potential_new_price = current_price # No immediate change in this simplified model
            else:
                # Moderate stock, adjust based on demand score if it's significantly different from base
                demand_driven_adjustment = base_price * DEMAND_SCORE_MULTIPLIER * demand_score
                potential_new_price = base_price + demand_driven_adjustment # Adjusting from base price for moderate stock
                adjustment_reason = f"Moderate stock ({stock_level}), demand score: {demand_score}"

            # 3. Apply limits and update if necessary
            if potential_new_price != current_price:
                min_price = current_price * (1 - PRICE_ADJUSTMENT_LIMIT_PERCENT)
                max_price = current_price * (1 + PRICE_ADJUSTMENT_LIMIT_PERCENT)
                new_price = max(min_price, min(max_price, potential_new_price))

                if new_price != current_price:
                    app.logger.info(f"Updating price for {product_id}: {current_price} -> {new_price:.2f} ({adjustment_reason})")
                    cur.execute(
                        "UPDATE product_pricing SET current_price = %s, last_price_update = %s WHERE product_id = %s",
                        (new_price, datetime.utcnow(), product_id)
                    )
                    conn.commit()
                    updated_count += 1

        cur.close()
        conn.close()
        return jsonify({"message": f"Price adjustment complete. {updated_count} products updated."}), 200

    except Exception as e:
        app.logger.error(f"Error during price adjustment: {e}")
        return jsonify({"error": str(e)}), 500

if __name__ == '__main__':
    # In production, use a proper WSGI server like Gunicorn
    app.run(debug=True, host='0.0.0.0', port=5001)

Scheduling the Price Adjustment

This microservice needs to be triggered periodically. A cron job or a dedicated scheduler like Celery Beat is ideal. Here’s a simple cron entry to run it every hour:

# Run price adjustment script every hour
0 * * * * /usr/bin/env python3 /path/to/your/price_adjuster.py >> /var/log/price_adjuster.log 2>&1

Note: The Python script above is a simplified example. A production-ready system would require robust error handling, rate limiting for API calls, more sophisticated demand scoring (incorporating sales velocity, conversion rates, time-on-site), and potentially a separate service for managing pricing rules and parameters.

2. Subscription Box Tiering with Feature Gating

Moving beyond one-off sales, recurring revenue from subscription boxes is a powerful profit driver. The key is to create compelling tiers that encourage upgrades and to implement robust feature gating to manage what each subscriber receives. This requires careful product curation and a flexible backend system.

Subscription Tiers and Feature Mapping

Define distinct tiers with clear value propositions. For example:

• Basic Box: 3-5 curated items, standard shipping.
• Premium Box: 5-7 items, including 1-2 exclusive/higher-value items, faster shipping, early access to new products.
• Deluxe Box: 7-10 items, all exclusive/premium items, priority shipping, personalized recommendations, dedicated support.

Each “feature” (e.g., “exclusive item”, “faster shipping”, “personalized recommendations”) needs to be programmatically controllable.

Backend Implementation (PHP Example)

We’ll use PHP to manage subscription plans and user entitlements. Assume a database table `subscriptions` with `user_id`, `plan_id`, `start_date`, `end_date`, and `status`. A `plans` table stores tier information, and a `plan_features` table links plans to specific features.

<?php

class SubscriptionManager {
    private $db; // PDO database connection

    public function __construct(PDO $db) {
        $this->db = $db;
    }

    public function getUserSubscription(int $userId): ?array {
        $stmt = $this->db->prepare("
            SELECT s.plan_id, p.name as plan_name
            FROM subscriptions s
            JOIN plans p ON s.plan_id = p.id
            WHERE s.user_id = :userId AND s.status = 'active'
            ORDER BY s.start_date DESC
            LIMIT 1
        ");
        $stmt->execute([':userId' => $userId]);
        $subscription = $stmt->fetch(PDO::FETCH_ASSOC);
        return $subscription ?: null;
    }

    public function getPlanFeatures(int $planId): array {
        $stmt = $this->db->prepare("
            SELECT pf.feature_key, pf.feature_value
            FROM plan_features pf
            WHERE pf.plan_id = :planId
        ");
        $stmt->execute([':planId' => $planId]);
        $features = $stmt->fetchAll(PDO::FETCH_KEY_PAIR); // Returns [feature_key => feature_value]
        return $features ?: [];
    }

    public function hasFeature(int $userId, string $featureKey): bool {
        $subscription = $this->getUserSubscription($userId);
        if (!$subscription) {
            return false; // User not subscribed or subscription inactive
        }

        $planFeatures = $this->getPlanFeatures($subscription['plan_id']);

        // Check if the feature exists for the plan and if its value enables it
        // Example: feature_key='exclusive_item', feature_value='true'
        // Example: feature_key='shipping_speed', feature_value='priority'
        if (isset($planFeatures[$featureKey])) {
            $featureValue = $planFeatures[$featureKey];
            // Basic boolean check, can be extended for specific values
            if (is_string($featureValue) && strtolower($featureValue) === 'true') {
                return true;
            }
            // Add more complex logic here based on feature_value type and key
            // e.g., if ($featureKey === 'shipping_speed' && $featureValue === 'priority') return true;
            return (bool) $featureValue; // Attempt to cast to boolean
        }

        return false;
    }

    // Method to determine which products to include in a box for a user
    public function getBoxContents(int $userId, array $allAvailableProducts): array {
        $subscription = $this->getUserSubscription($userId);
        if (!$subscription) {
            return []; // No subscription, no box contents
        }

        $planFeatures = $this->getPlanFeatures($subscription['plan_id']);
        $boxItems = [];
        $itemCount = 0;

        // Example logic: Prioritize exclusive items for higher tiers
        $exclusiveItems = array_filter($allAvailableProducts, function($product) {
            return $product['is_exclusive'];
        });
        $standardItems = array_filter($allAvailableProducts, function($product) {
            return !$product['is_exclusive'];
        });

        if ($this->hasFeature($userId, 'exclusive_item')) {
            // Add a certain number of exclusive items based on tier/features
            $numExclusiveToAdd = isset($planFeatures['num_exclusive_items']) ? (int)$planFeatures['num_exclusive_items'] : 1;
            $addedExclusive = 0;
            foreach ($exclusiveItems as $item) {
                if ($addedExclusive < $numExclusiveToAdd) {
                    $boxItems[] = $item;
                    $addedExclusive++;
                } else {
                    break;
                }
            }
            $itemCount += $addedExclusive;
        }

        // Add standard items to reach the target count for the tier
        $targetItemCount = isset($planFeatures['target_item_count']) ? (int)$planFeatures['target_item_count'] : 5;
        $numStandardToAdd = $targetItemCount - $itemCount;

        if ($numStandardToAdd > 0) {
            // Shuffle standard items to provide variety if needed
            shuffle($standardItems);
            $addedStandard = 0;
            foreach ($standardItems as $item) {
                if ($addedStandard < $numStandardToAdd) {
                    $boxItems[] = $item;
                    $addedStandard++;
                } else {
                    break;
                }
            }
        }

        // Further logic for personalization, shipping speed, etc. would go here
        // based on other features retrieved via $this->hasFeature()

        return $boxItems;
    }
}

// Example Usage (assuming $pdo is a valid PDO connection)
/*
$subscriptionManager = new SubscriptionManager($pdo);
$userId = 123;

if ($subscriptionManager->hasFeature($userId, 'priority_shipping')) {
    echo "User has priority shipping!\n";
}

$allProducts = [
    ['id' => 'P001', 'name' => 'Basic Widget', 'is_exclusive' => false],
    ['id' => 'P002', 'name' => 'Advanced Gadget', 'is_exclusive' => false],
    ['id' => 'P003', 'name' => 'Exclusive Art Piece', 'is_exclusive' => true],
    ['id' => 'P004', 'name' => 'Premium Tool', 'is_exclusive' => true],
];

$boxContents = $subscriptionManager->getBoxContents($userId, $allProducts);
print_r($boxContents);
*/
?>

Database Schema Snippets

-- Simplified schema
CREATE TABLE plans (
    id SERIAL PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    price DECIMAL(10, 2) NOT NULL,
    description TEXT
);

CREATE TABLE subscriptions (
    id SERIAL PRIMARY KEY,
    user_id INT NOT NULL,
    plan_id INT NOT NULL,
    start_date TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
    end_date TIMESTAMP WITH TIME ZONE,
    status VARCHAR(50) NOT NULL DEFAULT 'active' -- e.g., active, cancelled, paused
);

CREATE TABLE plan_features (
    id SERIAL PRIMARY KEY,
    plan_id INT NOT NULL REFERENCES plans(id),
    feature_key VARCHAR(100) NOT NULL,
    feature_value VARCHAR(255) NOT NULL, -- Can store 'true'/'false', 'priority', '10', etc.
    UNIQUE (plan_id, feature_key)
);

-- Example Data
INSERT INTO plans (name, price) VALUES
('Basic Box', 29.99),
('Premium Box', 59.99),
('Deluxe Box', 99.99);

INSERT INTO plan_features (plan_id, feature_key, feature_value) VALUES
(1, 'target_item_count', '4'),
(1, 'exclusive_item', 'false'),
(2, 'target_item_count', '6'),
(2, 'exclusive_item', 'true'),
(2, 'num_exclusive_items', '1'),
(2, 'shipping_speed', 'standard'),
(3, 'target_item_count', '8'),
(3, 'exclusive_item', 'true'),
(3, 'num_exclusive_items', '3'),
(3, 'shipping_speed', 'priority'),
(3, 'personalized_recommendations', 'true');

3. Upsell/Cross-sell Engine Based on Behavioral Analytics

This playbook focuses on increasing Average Order Value (AOV) by intelligently suggesting complementary products or upgrades at precisely the right moment in the customer journey. This requires capturing and analyzing user behavior data.

Data Capture and Event Streaming

Implement event tracking on your frontend (e.g., using JavaScript) to capture key user interactions:

• `product_viewed`: `{“user_id”: “…”, “product_id”: “…”, “timestamp”: “…”}`
• `added_to_cart`: `{“user_id”: “…”, “product_id”: “…”, “quantity”: 1, “timestamp”: “…”}`
• `checkout_started`: `{“user_id”: “…”, “cart_id”: “…”, “timestamp”: “…”}`
• `order_completed`: `{“user_id”: “…”, “order_id”: “…”, “total_amount”: “…”, “items”: […]}`

These events should be streamed to a message queue (like Kafka or RabbitMQ) or a data lake for real-time processing.

Recommendation Logic (Python Example)

A backend service can consume these events and generate recommendations. We’ll use a simplified approach based on co-occurrence (items frequently bought together).

from kafka import KafkaConsumer
import json
import redis # For caching recommendations

# Configuration
KAFKA_BROKER = 'localhost:9092'
EVENTS_TOPIC = 'user_events'
RECOMMENDATIONS_CHANNEL = 'recommendations'
REDIS_HOST = 'localhost'
REDIS_PORT = 6379

# Assume a pre-computed 'frequently_bought_together' mapping
# This would typically be generated offline via batch processing (e.g., Spark MLlib, Apriori algorithm)
# Format: { "product_id_A": ["product_id_B", "product_id_C"], ... }
FREQUENTLY_BOUGHT_TOGETHER = {
    "SKU1001": ["SKU1005", "SKU2010"],
    "SKU1002": ["SKU1001", "SKU3005"],
    "SKU2010": ["SKU1001", "SKU2015"],
    # ... more mappings
}

def get_recommendations(product_id, current_cart_items):
    """
    Generates recommendations for a given product, excluding items already in cart.
    """
    if product_id not in FREQUENTLY_BOUGHT_TOGETHER:
        return []

    potential_recs = FREQUENTLY_BOUGHT_TOGETHER[product_id]
    
    # Filter out items already in the cart
    recs = [rec_id for rec_id in potential_recs if rec_id not in current_cart_items]
    
    return recs

def process_events():
    consumer = KafkaConsumer(
        EVENTS_TOPIC,
        bootstrap_servers=[KAFKA_BROKER],
        auto_offset_reset='earliest',
        enable_auto_commit=True,
        group_id='recommendation-engine',
        value_deserializer=lambda x: json.loads(x.decode('utf-8'))
    )

    r = redis.StrictRedis(host=REDIS_HOST, port=REDIS_PORT, decode_responses=True)

    print("Starting event consumer...")
    for message in consumer:
        event_data = message.value
        event_type = event_data.get('event_type')
        user_id = event_data.get('user_id')

        if not user_id:
            continue

        # Example: Trigger recommendations when a product is viewed or added to cart
        if event_type in ['product_viewed', 'added_to_cart']:
            product_id = event_data.get('product_id')
            if not product_id:
                continue

            # Fetch current cart items for this user (this would be a DB lookup)
            # For simplicity, we'll assume cart data is available or fetched elsewhere
            # In a real system, you might maintain user sessions/carts in Redis
            current_cart_items = [] # Placeholder: Fetch actual cart items for user_id
            
            # Example: If event is 'added_to_cart', update cart items
            if event_type == 'added_to_cart':
                 current_cart_items.append(product_id) # Simplified

            recommendations = get_recommendations(product_id, current_cart_items)

            if recommendations:
                # Store recommendations, perhaps keyed by user_id or product_id
                # A pub/sub mechanism can notify the frontend
                r.publish(f"user:{user_id}:recommendations", json.dumps(recommendations))
                print(f"Published recommendations for user {user_id}: {recommendations}")
        
        # More complex logic for checkout_started, order_completed etc.
        # could trigger different types of recommendations (e.g., "Customers who bought X also bought Y")

if __name__ == '__main__':
    # In production, run this using a process manager like systemd or supervisord
    process_events()

Frontend Integration (Conceptual JavaScript)

The frontend needs to subscribe to recommendation updates.

// Assuming a WebSocket connection or Server-Sent Events (SSE) endpoint
// that receives recommendations pushed from the backend.

// Example using a hypothetical WebSocket connection
const userId = 'user123'; // Get dynamically
const socket = new WebSocket(`ws://your-api.com/ws/recommendations/${userId}`);

socket.onmessage = (event) => {
    const recommendations = JSON.parse(event.data);
    console.log('Received recommendations:', recommendations);
    // Logic to display these recommendations in the UI (e.g., a carousel)
    displayRecommendations(recommendations);
};

socket.onopen = () => {
    console.log('WebSocket connection established.');
};

socket.onerror = (error) => {
    console.error('WebSocket error:', error);
};

function displayRecommendations(recs) {
    const container = document.getElementById('recommendations-container');
    if (!container) return;
    container.innerHTML = ''; // Clear previous recommendations

    recs.forEach(productId => {
        // Fetch product details (name, image, price) via API and render
        const productElement = document.createElement('div');
        productElement.textContent = `Recommended: ${productId}`; // Replace with actual product info
        container.appendChild(productElement);
    });
}

4. Personalized Email Marketing Automation with Segmentation

Generic email blasts are dead. True profit comes from hyper-personalized campaigns triggered by user behavior, purchase history, and declared preferences. This requires a robust CRM and marketing automation platform, but the core logic can be built with custom services.

Segmentation Criteria

Define dynamic segments based on data points:

• Purchase History: High-value customers, frequent buyers, customers who bought specific product categories.
• Browsing Behavior: Users who viewed specific products/categories multiple times, abandoned carts.
• Demographics/Preferences: Location, stated interests (if collected).
• Engagement: Email open rates, click-through rates.

Automated Campaign Triggers (Python Example)

A service that monitors user data changes and triggers email campaigns via an ESP (Email Service Provider) API (e.g., SendGrid, Mailgun).

import requests
import json
from datetime import datetime, timedelta
import os

# Configuration
ESP_API_KEY = os.environ.get("ESP_API_KEY")
ESP_SEND_URL = "https://api.sendgrid.com/v3/mail/send" # Example for SendGrid
DB_HOST = os.environ.get("DB_HOST", "localhost")
DB_NAME = os.environ.get("DB_NAME", "ecommerce")
DB_USER = os.environ.get("DB_USER", "user")
DB_PASSWORD = os.environ.get("DB_PASSWORD", "password")

# Assume a function to fetch user data and segment membership
def get_users_in_segment(segment_name):
    # This would involve complex SQL queries or calls to a CRM API
    # Example: Fetch users who abandoned carts in the last 48 hours
    if segment_name == "abandoned_cart_recent":
        conn = psycopg2.connect(host=DB_HOST, database=DB_NAME, user=DB_USER, password=DB_PASSWORD)
        cur = conn.cursor()
        # Simplified query: find users with items in cart but no completed order recently
        cur.execute("""
            SELECT DISTINCT u.id, u.email, u.first_name
            FROM users u
            JOIN carts c ON u.id = c.user_id
            LEFT JOIN orders o ON u.id = o.user_id AND o.order_date >= NOW() - INTERVAL '48 hours'
            WHERE c.status = 'active' AND o.id IS NULL
            AND u.last_email_sent_at < NOW() - INTERVAL '24 hours' -- Avoid spamming
        """)
        users = cur.fetchall()
        cur.close()
        conn.close()
        return [{"id": u[0], "email": u[1], "first_name": u[2]} for u in users]
    return []

def send_email(to_email, subject, html_content, user_id=None):
    headers = {
        "Authorization": f"Bearer {ESP_API_KEY}",
        "Content-Type": "application/json",
    }
    payload = {
        "personalizations": [{
            "to": [{"email": to_email}],
            "subject": subject
        }],
        "from": {"email": "[email protected]"},
        "content": [{"type": "text/html", "value": html_content}]
    }
    # Add dynamic template data if needed (e.g., user's name)
    if user_id:
         # payload["personalizations"][0]["dynamic_template_data"] = {"user_id": user_id, ...}
         pass # Placeholder

    try:
        response = requests.post(ESP_SEND_URL, headers=headers, json=payload)
        response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx)
        print(f"Email sent to {to_email}: {response.status_code}")
        return True
    except requests.exceptions.RequestException as e:
        print(f"Error sending email to {to_email}: {e}")
        return False

def trigger_campaigns():
    # 1. Abandoned Cart Campaign
    abandoned_users = get_users_in_segment("abandoned_cart_recent")
    for user in abandoned_users:
        # Fetch cart details for the user (requires another DB query)
        cart_items_html = "
Item 1
Item 2
" # Placeholder
        subject = f"Did you forget something, {user['first_name']}?"
        html_content = f"""
        
Hi {user['first_name']},
        
We noticed you left some items in your cart:
        {cart_items_html}
        
Complete your order
        """
        if send_email(user['email'], subject, html_content, user_id=user['id']):
            # Update user's last_email_sent_at in DB
            pass # Placeholder

    # 2. Post-Purchase Follow-up Campaign (e.g., ask for review)
    # Logic to find recent orders without reviews and trigger emails

    # 3. Re-engagement Campaign for inactive users
    # Logic to find users inactive for X days and send a special offer

if __name__ == '__main__':
    # Schedule this script to run periodically (e.g., every 15 minutes)
    trigger_campaigns()

5. Tiered Loyalty Program with Gamification

Retaining existing customers is far more profitable than acquiring new ones. A well-structured loyalty program, enhanced with gamification elements, encourages repeat purchases and increases customer lifetime value (CLV).

Loyalty Tiers and Benefits

Define tiers based on accumulated points or spending thresholds:

• Bronze: 1 point per $1 spent. Basic member perks.
• Silver: 1.25 points per $1 spent. Free standard shipping on orders over $50.
• Gold: 1.5 points per $1 spent. Free expedited shipping. Early access to sales. Birthday bonus points.
• Platinum: 2 points per $1 spent. Dedicated support line. Exclusive product drops. Annual gift.

Gamification Elements

Introduce elements that make participation engaging:

• Challenges: “Earn 50 bonus points by making 3 purchases this month.”
• Badges: Awarded for milestones (e.g., “First Purchase”, “Loyalty Veteran”, “Top Spender”).
• Spin-the-Wheel: Occasional opportunities to win bonus points or discounts.
• Referral Bonuses: Points for referring new customers.

Backend Logic (Ruby Example)

Manage points, tiers, and rewards. This example uses Ruby on Rails conventions.

# app/models/user.rb
class User << ApplicationRecord
  has_many :loyalty_transactions
  has_many :badges, through: :user_badges

  # Define loyalty tiers and their thresholds
  TIERS = {
    'bronze' => { points_threshold: 0, points_multiplier: 1.0 },
    'silver' => { points_threshold: 500, points_multiplier: 1.25 },
    'gold'   => { points_threshold: 2000, points_multiplier: 1.5 },
    'platinum' => { points_threshold: 5000, points_multiplier: 2.0 }
  }.freeze

  def current_points
    loyalty_transactions.sum(:points_earned)
  end

  def current_tier
    tier_name = 'bronze' # Default
    TIERS.each do |name, config|
      if current_points >= config[:points_threshold]
        tier_name = name
      else
        break # Stop once threshold is not met
      end
    end
    tier_name.to_sym
  end

  def points_multiplier
    TIERS[current_tier][:points_multiplier]
  end

  # Method to add points from an order
  def add_points_from_order(order)
    points_to_add = (order.total_amount * points_multiplier).to_i
    loyalty_transactions.create!(
      order_id: order.id,
      points_earned: points_to_add,
      transaction_type: 'order_purchase'
    )
    # Check for tier upgrade and award badges/notifications
    check_for_tier_upgrade(points_to_add)
  end

  # Method to redeem points for a reward
  def redeem_reward(reward)
    if current_points >= reward