Top 5 E-commerce Micro-Business Monetization Playbooks to Explode Profits to Minimize Server Costs and Load Overhead

Playbook 1: Tiered Feature Gating with API-Driven Subscriptions

This playbook focuses on segmenting your user base and monetizing advanced features by implementing a robust subscription system. The core idea is to offer a free or basic tier with essential functionality and progressively unlock more powerful features, higher usage limits, or premium support through paid subscription plans. This directly minimizes server load by ensuring that only paying users consume resources for advanced features.

We’ll use a combination of a backend API (e.g., in PHP/Laravel) to manage user entitlements and a frontend (e.g., React/Vue) to conditionally render features based on these entitlements. For payment processing, we’ll integrate with Stripe.

Backend API Implementation (PHP/Laravel Example)

First, define your subscription plans and associated feature flags in your database. A simple `plans` table and a `user_subscriptions` table are a good start.

-- plans table
CREATE TABLE plans (
    id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(255) NOT NULL,
    price_monthly DECIMAL(10, 2) NOT NULL,
    features JSON -- e.g., {"api_calls_limit": 1000, "advanced_reporting": true}
);

-- user_subscriptions table
CREATE TABLE user_subscriptions (
    id INT AUTO_INCREMENT PRIMARY KEY,
    user_id INT NOT NULL,
    plan_id INT NOT NULL,
    stripe_subscription_id VARCHAR(255) UNIQUE,
    status ENUM('active', 'canceled', 'past_due') DEFAULT 'active',
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
    FOREIGN KEY (user_id) REFERENCES users(id),
    FOREIGN KEY (plan_id) REFERENCES plans(id)
);

Next, create an API endpoint to fetch user entitlements. This endpoint will be called by the frontend to determine which features to display or enable.

// routes/api.php (Laravel example)
use App\Http\Controllers\UserController;

Route::middleware('auth:api')->get('/user/entitlements', [UserController::class, 'getEntitlements']);

// app/Http/Controllers/UserController.php
namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Models\User;
use App\Models\Plan;

class UserController extends Controller
{
    public function getEntitlements(Request $request)
    {
        $user = $request->user();
        $subscription = $user->currentSubscription; // Assuming a relationship is defined

        if (!$subscription || $subscription->status !== 'active') {
            // Return entitlements for a default/free tier
            $defaultPlan = Plan::where('name', 'Free')->first(); // Or a specific default plan ID
            return response()->json([
                'user_id' => $user->id,
                'plan_name' => 'Free',
                'features' => $defaultPlan ? $defaultPlan->features : (object)[]
            ]);
        }

        $plan = $subscription->plan;
        return response()->json([
            'user_id' => $user->id,
            'plan_name' => $plan->name,
            'features' => $plan->features
        ]);
    }
}

Implement Stripe webhooks to handle subscription status changes (e.g., `customer.subscription.created`, `customer.subscription.updated`, `customer.subscription.deleted`). This ensures your database is always in sync with Stripe’s records.

// app/Http/Controllers/StripeWebhookController.php
namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Log;
use App\Models\User;
use App\Models\Plan;
use App\Models\UserSubscription;
use Stripe\Event;
use Stripe\StripeClient;

class StripeWebhookController extends Controller
{
    public function handleWebhook(Request $request)
    {
        $stripe = new StripeClient(config('services.stripe.secret'));
        $payload = $request->getContent();
        $sig_header = $request->header('Stripe-Signature');
        $endpoint_secret = config('services.stripe.webhook_secret');

        try {
            $event = $stripe->webhooks->constructEvent(
                $payload, $sig_header, $endpoint_secret
            );
        } catch (\UnexpectedValueException $e) {
            // Invalid payload
            return response('Webhook error: Invalid payload', 400);
        } catch (\Stripe\Exception\SignatureVerificationException $e) {
            // Invalid signature
            return response('Webhook error: Invalid signature', 400);
        }

        // Handle the event
        switch ($event->type) {
            case 'customer.subscription.created':
                $subscription = $event->data->object;
                $this->handleSubscriptionCreated($subscription);
                break;
            case 'customer.subscription.updated':
                $subscription = $event->data->object;
                $this->handleSubscriptionUpdated($subscription);
                break;
            case 'customer.subscription.deleted':
                $subscription = $event->data->object;
                $this->handleSubscriptionDeleted($subscription);
                break;
            // ... handle other event types
            default:
                // Unexpected event type
                return response('Webhook error: Unhandled event type', 400);
        }

        return response('Webhook received', 200);
    }

    protected function handleSubscriptionCreated($subscriptionData)
    {
        $user = User::where('stripe_customer_id', $subscriptionData->customer)->first();
        if (!$user) {
            Log::warning("Stripe webhook: User not found for customer ID {$subscriptionData->customer}");
            return;
        }

        $plan = Plan::where('stripe_plan_id', $subscriptionData->plan->id)->first(); // Assuming you map Stripe plan IDs
        if (!$plan) {
            Log::warning("Stripe webhook: Plan not found for Stripe plan ID {$subscriptionData->plan->id}");
            return;
        }

        UserSubscription::create([
            'user_id' => $user->id,
            'plan_id' => $plan->id,
            'stripe_subscription_id' => $subscriptionData->id,
            'status' => $subscriptionData->status,
        ]);
        Log::info("Stripe webhook: Subscription created for user {$user->id}, Stripe ID {$subscriptionData->id}");
    }

    protected function handleSubscriptionUpdated($subscriptionData)
    {
        $userSubscription = UserSubscription::where('stripe_subscription_id', $subscriptionData->id)->first();
        if (!$userSubscription) {
            Log::warning("Stripe webhook: User subscription not found for Stripe ID {$subscriptionData->id}");
            return;
        }

        // Handle plan changes, status changes (e.g., past_due, active)
        if ($subscriptionData->plan->id !== $userSubscription->plan->stripe_plan_id) {
            $newPlan = Plan::where('stripe_plan_id', $subscriptionData->plan->id)->first();
            if ($newPlan) {
                $userSubscription->plan_id = $newPlan->id;
            }
        }
        $userSubscription->status = $subscriptionData->status;
        $userSubscription->save();
        Log::info("Stripe webhook: Subscription updated for Stripe ID {$subscriptionData->id}, Status: {$subscriptionData->status}");
    }

    protected function handleSubscriptionDeleted($subscriptionData)
    {
        $userSubscription = UserSubscription::where('stripe_subscription_id', $subscriptionData->id)->first();
        if (!$userSubscription) {
            Log::warning("Stripe webhook: User subscription not found for Stripe ID {$subscriptionData->id}");
            return;
        }

        $userSubscription->status = 'canceled';
        $userSubscription->save();
        Log::info("Stripe webhook: Subscription deleted for Stripe ID {$subscriptionData->id}");
    }
}

Frontend Implementation (React Example)

On the frontend, fetch user entitlements when the application loads or when the user’s authentication status changes. Then, conditionally render UI elements or enable/disable functionality based on the received features.

// src/contexts/AuthContext.js
import React, { createContext, useState, useContext, useEffect } from 'react';
import api from '../services/api'; // Your API service

const AuthContext = createContext();

export const AuthProvider = ({ children }) => {
    const [user, setUser] = useState(null);
    const [entitlements, setEntitlements] = useState({});
    const [isLoading, setIsLoading] = useState(true);

    useEffect(() => {
        // Fetch user and entitlements on app load
        const fetchUserData = async () => {
            try {
                setIsLoading(true);
                // Assume a /user endpoint also exists to get basic user info
                const userResponse = await api.get('/user');
                setUser(userResponse.data);

                const entitlementsResponse = await api.get('/user/entitlements');
                setEntitlements(entitlementsResponse.data.features);
            } catch (error) {
                console.error("Failed to fetch user data or entitlements:", error);
                setUser(null);
                setEntitlements({});
            } finally {
                setIsLoading(false);
            }
        };
        fetchUserData();
    }, []); // Empty dependency array means this runs once on mount

    // You would also have login/logout functions here that update user and entitlements

    return (
        
            {children}
        
    );
};

export const useAuth = () => useContext(AuthContext);

// src/components/FeatureComponent.js
import React from 'react';
import { useAuth } from '../contexts/AuthContext';

const FeatureComponent = () => {
    const { entitlements } = useAuth();

    // Check if the advanced reporting feature is enabled for the current user
    const isAdvancedReportingEnabled = entitlements && entitlements.advanced_reporting === true;
    const apiCallsLimit = entitlements && entitlements.api_calls_limit ? entitlements.api_calls_limit : 0;

    return (
        <div>
            <h3>Your Dashboard</h3>
            {isAdvancedReportingEnabled ? (
                <div>
                    <h4>Advanced Reporting</h4>
                    <p>Access detailed analytics and insights.</p>
                    <!-- Render advanced reporting UI -->
                </div>
            ) : (
                <div>
                    <p>Upgrade to unlock Advanced Reporting.</p>
                    <!-- Link to upgrade page -->
                </div>
            )}
            <p>API Calls Remaining: {apiCallsLimit} (This is a placeholder, actual usage tracking needed)</p>
            <!-- Other components -->
        </div>
    );
};

export default FeatureComponent;

This approach ensures that expensive computations or resource-intensive features are only accessible to users who are paying for them, thereby directly reducing server load and operational costs for the majority of your user base.

Playbook 2: Usage-Based Metering for API Services

For businesses offering APIs or services with quantifiable usage (e.g., data processing, image transformations, AI model inference), a usage-based pricing model is highly effective. This directly ties revenue to consumption, ensuring that users pay for what they use, and you only incur server costs for active, revenue-generating requests.

Backend Metering and Billing Logic

Implement a robust metering system. This involves tracking specific events or resource consumption per user or API key. We’ll use Redis for high-speed, in-memory counters and a background job processor (e.g., Laravel Queues) to periodically aggregate and bill.

// app/Services/MeteringService.php
namespace App\Services;

use Illuminate\Support\Facades\Redis;
use Illuminate\Support\Facades\Log;
use App\Models\User;
use App\Models\ApiUsageRecord; // A model to store historical usage for billing

class MeteringService
{
    const REDIS_KEY_PREFIX = 'api_usage:';

    public function recordUsage(User $user, string $eventType, int $quantity = 1)
    {
        $key = self::REDIS_KEY_PREFIX . $user->id . ':' . $eventType;
        // Increment the counter in Redis. TTL can be set to expire daily/hourly.
        $currentCount = Redis::incrby($key, $quantity);
        Redis::expire($key, 86400); // Expire after 24 hours

        Log::info("Usage recorded for user {$user->id}: {$eventType} = {$quantity}. New total: {$currentCount}");
    }

    public function getUsage(User $user, string $eventType): int
    {
        $key = self::REDIS_KEY_PREFIX . $user->id . ':' . $eventType;
        return (int) Redis::get($key) ?? 0;
    }

    // This method would be called by a scheduled job
    public function aggregateAndBill()
    {
        $users = User::all(); // In production, fetch users with active subscriptions/billing enabled

        foreach ($users as $user) {
            $usageData = [];
            // Fetch all relevant usage keys for the user
            $keys = Redis::keys(self::REDIS_KEY_PREFIX . $user->id . ':*');

            foreach ($keys as $key) {
                $eventType = str_replace(self::REDIS_KEY_PREFIX . $user->id . ':', '', $key);
                $quantity = (int) Redis::get($key);

                if ($quantity > 0) {
                    $usageData[$eventType] = $quantity;
                    // Store in historical records for billing
                    ApiUsageRecord::create([
                        'user_id' => $user->id,
                        'event_type' => $eventType,
                        'quantity' => $quantity,
                        'billed_at' => null, // Will be set when invoiced
                    ]);
                    // Reset the Redis counter for the next period
                    Redis::del($key);
                }
            }

            if (!empty($usageData)) {
                Log::info("Aggregated usage for user {$user->id}: " . json_encode($usageData));
                // Trigger billing process for this user based on usageData
                // This might involve calculating costs, creating invoices, and charging via Stripe
                $this->processBillingForUser($user, $usageData);
            }
        }
    }

    protected function processBillingForUser(User $user, array $usageData)
    {
        // Logic to calculate costs based on pricing tiers and usageData
        // e.g., $cost = calculateCost($usageData, $user->plan->pricing_model);
        // Then, use Stripe to create an invoice or charge the customer.
        Log::info("Billing processed for user {$user->id}. Usage: " . json_encode($usageData));
    }
}

Integrate this service into your API request handlers. For example, if you have an image processing API endpoint:

// app/Http/Controllers/ImageProcessingController.php
namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Services\MeteringService;
use App\Services\ImageProcessor; // Your image processing service

class ImageProcessingController extends Controller
{
    protected $meteringService;
    protected $imageProcessor;

    public function __construct(MeteringService $meteringService, ImageProcessor $imageProcessor)
    {
        $this->meteringService = $meteringService;
        $this->imageProcessor = $imageProcessor;
    }

    public function process(Request $request)
    {
        $user = $request->user(); // Assuming authenticated user

        // Check if user has enough credits or is on a plan that allows this operation
        // ...

        try {
            $processedImage = $this->imageProcessor->resize($request->file('image'), 200, 200);

            // Record the usage after successful processing
            $this->meteringService->recordUsage($user, 'image_resize_operations', 1);

            return response()->json(['message' => 'Image processed successfully']);
        } catch (\Exception $e) {
            // Optionally record failed operations if you charge for them or want to track errors
            // $this->meteringService->recordUsage($user, 'image_resize_failures', 1);
            Log::error("Image processing failed for user {$user->id}: " . $e->getMessage());
            return response()->json(['error' => 'Image processing failed'], 500);
        }
    }
}

Schedule the `aggregateAndBill` method to run periodically (e.g., daily) using your task scheduler (e.g., `cron` with Laravel’s scheduler).

# In your Laravel app/Console/Kernel.php
protected function schedule(Schedule $schedule)
{
    $schedule->call(function () {
        app(App\Services\MeteringService::class)->aggregateAndBill();
    })->dailyAt('01:00'); // Run daily at 1 AM
}

This model ensures that your infrastructure costs scale directly with revenue. By using efficient in-memory stores like Redis for real-time tracking and background jobs for aggregation, you minimize the performance impact on your live API endpoints.

Playbook 3: Freemium with Time-Limited Trials and Upsell Prompts

The freemium model is a classic for user acquisition, but to monetize effectively, it needs strategic upsell mechanics. This playbook focuses on offering a compelling free tier, a generous trial of premium features, and intelligent prompts to convert free users to paid subscribers. The server cost benefit comes from the fact that the majority of users remain on the free tier, consuming minimal resources, while the trial users are a temporary, controlled load.

Trial Management and Feature Flagging

Extend the feature flagging system from Playbook 1 to include trial periods. Store trial expiration dates for users.

-- Add to user_subscriptions table or a new table
ALTER TABLE user_subscriptions
ADD COLUMN trial_ends_at TIMESTAMP NULL DEFAULT NULL;

// app/Http/Controllers/UserController.php (modified getEntitlements)
namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Models\User;
use App\Models\Plan;

class UserController extends Controller
{
    public function getEntitlements(Request $request)
    {
        $user = $request->user();
        $subscription = $user->currentSubscription; // Assuming a relationship

        $isTrialing = false;
        $trialFeatures = (object)[];
        $planName = 'Free';
        $features = Plan::where('name', 'Free')->first()->features ?? (object)[]; // Default free features

        if ($subscription) {
            if ($subscription->status === 'active') {
                $planName = $subscription->plan->name;
                $features = $subscription->plan->features;
            } elseif ($subscription->trial_ends_at && $subscription->trial_ends_at > now()) {
                $isTrialing = true;
                $planName = $subscription->plan->name . ' (Trial)';
                $features = $subscription->plan->features; // User gets premium features during trial
                $trialFeatures = [
                    'trial_ends_in_days' => now()->diffInDays($subscription->trial_ends_at),
                    'trial_ends_at' => $subscription->trial_ends_at->toIso8601String(),
                ];
            }
        }

        return response()->json([
            'user_id' => $user->id,
            'plan_name' => $planName,
            'features' => $features,
            'is_trialing' => $isTrialing,
            'trial_info' => $trialFeatures
        ]);
    }

    // Method to initiate a trial
    public function startTrial(Request $request)
    {
        $user = $request->user();
        $planId = $request->input('plan_id'); // The plan the user wants to trial

        // Validate plan_id and check if user is eligible for a trial
        // ...

        $plan = Plan::findOrFail($planId);
        $trialDurationDays = config('services.stripe.trial_duration_days', 14); // e.g., 14 days

        // Create or update subscription record with trial details
        $userSubscription = UserSubscription::updateOrCreate(
            ['user_id' => $user->id],
            [
                'plan_id' => $plan->id,
                'status' => 'trialing', // Stripe status might differ, this is internal
                'trial_ends_at' => now()->addDays($trialDurationDays),
                'stripe_subscription_id' => null, // Will be set upon actual subscription
            ]
        );

        // Optionally, immediately trigger Stripe checkout for the trial
        // This is more complex and involves Stripe Checkout sessions

        return response()->json(['message' => 'Trial started successfully', 'trial_ends_at' => $userSubscription->trial_ends_at]);
    }
}

Intelligent Upsell Prompts

Implement logic in your frontend to display contextual upsell prompts. These should be triggered by user actions or when they attempt to access a premium feature they don’t have access to.

// src/components/UpsellPrompt.js
import React from 'react';
import { useAuth } from '../contexts/AuthContext';

const UpsellPrompt = ({ featureName }) => {
    const { entitlements, user } = useAuth();

    // Determine if the user is on a free plan and doesn't have the feature
    const isFreeUser = entitlements && entitlements.plan_name === 'Free';
    const hasFeature = entitlements && entitlements[featureName] === true;

    if (isFreeUser && !hasFeature) {
        return (
            <div className="upsell-banner">
                <p>Unlock {featureName.replace('_', ' ')} and more! </p>
                <button onClick={() => alert('Navigate to upgrade page')}>Upgrade Now</button>
            </div>
        );
    }

    // Also consider prompts for users nearing trial end
    if (entitlements && entitlements.is_trialing && entitlements.trial_info.trial_ends_in_days <= 3) {
         return (
            <div className="upsell-banner trial-ending">
                <p>Your trial for {entitlements.plan_name} ends in {entitlements.trial_info.trial_ends_in_days} days. Continue enjoying premium features by subscribing.</p>
                <button onClick={() => alert('Navigate to upgrade page')}>Subscribe</button>
            </div>
        );
    }

    return null; // No prompt needed
};

export default UpsellPrompt;

// Example usage in another component
// <UpsellPrompt featureName="advanced_reporting" />

By carefully managing trials and providing timely, relevant upsell opportunities, you can convert a portion of your free user base into paying customers without overwhelming your infrastructure. The key is to ensure the free tier is valuable enough to attract users, but limited enough to encourage upgrades.

Playbook 4: Content Monetization via Paywalls and Memberships

If your e-commerce business involves significant content creation (blog posts, tutorials, guides, exclusive product insights), implementing paywalls and membership tiers can create a recurring revenue stream. This model is particularly effective for businesses with strong brand authority and a loyal audience. Server load is managed by serving content dynamically based on user membership status.

Backend Content Access Control

Your content management system (CMS) or custom backend needs to integrate with your user and subscription system. Each piece of content should have an access level requirement.

-- Add to your content table (e.g., posts, articles)
ALTER TABLE posts
ADD COLUMN access_level VARCHAR(50) DEFAULT 'public'; -- e.g., 'public', 'subscriber', 'premium_member'

// app/Http/Controllers/ContentController.php
namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Models\Post;
use App\Models\User; // Assuming User model has subscription relationship

class ContentController extends Controller
{
    public function show($slug)
    {
        $post = Post::where('slug', $slug)->firstOrFail();
        $user = auth()->user(); // Get authenticated user

        $canAccess = $this->checkAccess($user, $post);

        if (!$canAccess) {
            // Redirect to login, subscription page, or show a paywall message
            return response()->json(['message' => 'Access denied. Please subscribe or log in.'], 403);
        }

        return response()->json($post);
    }

    protected function checkAccess(?User $user, Post $post): bool
    {
        if ($post->access_level === 'public') {
            return true;
        }

        if (!$user) {
            return false; // Not logged in, cannot access private content
        }

        $subscription = $user->currentSubscription; // Assuming relationship

        if (!$subscription || $subscription->status !== 'active') {
            return false; // Logged in but no active subscription
        }

        // Map subscription plan to required access level
        switch ($subscription->plan->name) {
            case 'Free':
                return $post->access_level === 'public';
            case 'Subscriber':
                return $post->access_level === 'public' || $post->access_level === 'subscriber';
            case 'Premium Member':
                return $post->access_level === 'public' || $post->access_level === 'subscriber' || $post->access_level === 'premium_member';
            default:
                return false;
        }
    }

    // Method to get content list, filtering by user's access
    public function index(Request $request)
    {
        $user = auth()->user();
        $query = Post::query();

        if (!$user) {
            $query->where('access_level', 'public');
        } else {
            $subscription = $user->currentSubscription;
            $accessLevel = 'public'; // Default for logged-out users
            if ($subscription && $subscription->status === 'active') {
                switch ($subscription->plan->name) {
                    case 'Free': $accessLevel = 'public'; break;
                    case 'Subscriber': $accessLevel = 'subscriber'; break;
                    case 'Premium Member': $accessLevel = 'premium_member'; break;
                }
            }
            // Fetch content the user can access
            $query->whereIn('access_level', ['public', $accessLevel]);
        }

        return $query->get();
    }
}

Frontend Content Rendering

On the frontend, fetch content and conditionally display it or a paywall message.

// src/components/ContentDisplay.js
import React, { useState, useEffect } from 'react';
import api from '../services/api';
import { useAuth } from '../contexts/AuthContext';

const ContentDisplay = ({ slug }) => {
    const [content, setContent] = useState(null);
    const [error, setError] = useState(null);
    const { user, isLoading } = useAuth();

    useEffect(() => {
        const fetchContent = async () => {
            try {
                const response = await api.get(`/content/${slug}`);
                setContent(response.data);
                setError(null);
            } catch (err) {
                if (err.response && err.response.status === 403) {
                    setError('Access Denied');
                    setContent(null); // Ensure no partial content is shown
                } else {
                    setError('Failed to load content.');
                    setContent(null);
                }
            }
        };
        fetchContent();
    }, [slug, user]); // Re-fetch if slug or user changes

    if (isLoading) return <p>Loading...</p>;
    if (error === 'Access Denied') {
        return (
            <div className="paywall">
                <h2>Content Locked</h2>
                <p>This content requires a subscription. </p>
                <button onClick={() => alert('Navigate to subscription page')}>Subscribe Now</button>
            </div>
        );
    }
    if (error) return <p>{error}</p>;
    if (!content) return null;

    return (
        <div className="content-article">
            <h1>{content.title}</h1>
            <p>{content.body}</p>
            <!-- Render other content fields -->
        </div>
    );
};

export default ContentDisplay;

This strategy leverages your existing content assets to generate recurring revenue. By dynamically controlling access, you ensure that only paying members consume resources for premium content, keeping the load manageable.

Playbook 5: Bundling and Upselling Complementary Services/Products

This playbook focuses on increasing Average Order Value (AOV) and customer lifetime value (CLV) by strategically bundling products or services and offering complementary upsells at key points in the customer journey. This doesn’t directly reduce server load but maximizes revenue from existing traffic and infrastructure, making each user interaction more profitable.

Dynamic Bundling Logic

Implement logic to create dynamic bundles based on user behavior, purchase history, or items currently in their cart. This can be done on the backend or frontend, depending on complexity.

// app/Services/BundleService.php
namespace App\Services;

use App\Models\Product;
use App\Models\User;
use Illuminate\Support\Collection;

class BundleService
{
    public function getBundlesForUser(User $user): Collection
    {
        $bundles = collect();
        $purchasedProductIds = $user->purchasedProducts()->pluck('product_id');

        // Example: Bundle 1 - "Starter Kit"
        // If user hasn't bought Product A and Product B, suggest buying them together
        if (!$purchasedProductIds->contains(1) && !$purchasedProductIds->contains(2)) {
            $productA = Product::find(1);
            $productB = Product::find(2);
            if ($productA && $productB) {
                $bundles->push([
                    'name' => 'Starter Kit',
                    'description' => 'Get started with essentials!',
                    'products' => [$productA, $productB],
                    'discount_percentage' => 10,
                    'price' => ($productA->price + $productB->price) * 0.9,
                ]);
            }
        }

        // Example: Bundle 2 - "Pro