Top 10 Custom Software Consultation Upsell Methods for Freelance Engineers to Scale to $10,000 Monthly Recurring Revenue (MRR)

1. Proactive Performance Audits as a Recurring Service

Many e-commerce businesses operate on legacy systems or have never conducted a comprehensive performance audit. This is a prime opportunity to offer a recurring service that goes beyond a one-off fix. Instead of waiting for a client’s site to slow down, proactively schedule quarterly or bi-annual deep dives into their application’s performance bottlenecks. This includes database query optimization, caching strategy refinement, and front-end asset delivery analysis.

For database performance, focus on identifying slow queries. A common tool for this is `pt-query-digest` from Percona Toolkit. Regularly analyze your slow query logs to pinpoint problematic SQL statements.

Example: Analyzing Slow Queries with `pt-query-digest`

# Assuming your MySQL slow query log is enabled and located at /var/log/mysql/mysql-slow.log
sudo pt-query-digest /var/log/mysql/mysql-slow.log > /tmp/slow_query_report.txt

# Then, review /tmp/slow_query_report.txt for the most frequent and time-consuming queries.
# Look for queries with high 'Rows examined' or 'Rows sent' relative to the actual work done.

For caching, analyze the effectiveness of your current Redis/Memcached setup or implement one if absent. This involves monitoring hit/miss ratios and optimizing key expiration strategies.

2. Security Hardening & Vulnerability Management Subscription

E-commerce sites are constant targets for malicious actors. Offer a monthly retainer for ongoing security monitoring, vulnerability scanning, and proactive patching. This isn’t just about fixing a breach; it’s about preventing one. This service can include regular penetration testing (automated and manual), dependency vulnerability checks, and secure configuration reviews.

Example: Automating Dependency Vulnerability Scans (PHP/Composer)

# Install the tool globally
composer global require roave/security-advisories

# Navigate to your project directory
cd /path/to/your/ecommerce/project

# Run the security check
composer update --dry-run --with-dependencies

# For automated checks, integrate this into your CI/CD pipeline.
# You can also use tools like Dependabot or Snyk for more advanced, integrated solutions.

For web application firewalls (WAFs), offer managed services. This could involve configuring and tuning ModSecurity rulesets for Apache/Nginx or managing cloud-based WAFs like AWS WAF or Cloudflare.

3. API Integration & Microservices Development Retainer

As e-commerce platforms grow, they often need to integrate with third-party services (payment gateways, shipping providers, CRM, ERP) or develop internal microservices. Offer a retainer for ongoing API integration work, including developing new integrations, maintaining existing ones, and building custom microservices to handle specific business logic. This requires a deep understanding of RESTful APIs, GraphQL, and message queues (e.g., RabbitMQ, Kafka).

Example: Building a Simple Product Sync Microservice (Python/Flask)

from flask import Flask, request, jsonify
import requests # For external API calls
import json

app = Flask(__name__)

# Assume this is your internal product database endpoint
INTERNAL_PRODUCT_API = "http://internal-api.example.com/products"
# Assume this is an external inventory management API
EXTERNAL_INVENTORY_API = "http://external-inventory.example.com/api/v1/products"

@app.route('/sync/products', methods=['POST'])
def sync_products():
    data = request.get_json()
    if not data or 'product_id' not in data:
        return jsonify({"error": "Missing product_id"}), 400

    product_id = data['product_id']

    try:
        # 1. Fetch product details from internal system
        internal_response = requests.get(f"{INTERNAL_PRODUCT_API}/{product_id}")
        internal_response.raise_for_status() # Raise an exception for bad status codes
        product_data = internal_response.json()

        # 2. Prepare data for external inventory system
        external_payload = {
            "sku": product_data.get("sku"),
            "quantity": product_data.get("stock_level"),
            "price": product_data.get("price")
        }

        # 3. Update external inventory system
        # This might be a PUT or POST depending on the API
        external_response = requests.put(f"{EXTERNAL_INVENTORY_API}/{product_id}", json=external_payload)
        external_response.raise_for_status()

        return jsonify({"message": f"Product {product_id} synced successfully"}), 200

    except requests.exceptions.RequestException as e:
        app.logger.error(f"API Error syncing product {product_id}: {e}")
        return jsonify({"error": f"Failed to sync product: {str(e)}"}), 500
    except Exception as e:
        app.logger.error(f"Unexpected error syncing product {product_id}: {e}")
        return jsonify({"error": f"An unexpected error occurred: {str(e)}"}), 500

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

This microservice can be deployed using Docker and orchestrated with Kubernetes, offering a scalable and maintainable solution.

4. CI/CD Pipeline Optimization & Management

A robust Continuous Integration and Continuous Deployment (CI/CD) pipeline is critical for rapid, reliable software releases. Many e-commerce businesses struggle with slow, error-prone pipelines. Offer a service to design, implement, and manage CI/CD pipelines using tools like Jenkins, GitLab CI, GitHub Actions, or CircleCI. This includes optimizing build times, automating testing (unit, integration, E2E), and implementing blue-green deployments or canary releases.

Example: Basic GitLab CI Configuration for a PHP Project

# .gitlab-ci.yml

image: php:8.1

stages:
  - build
  - test
  - deploy

variables:
  # Define database credentials for testing if needed
  DB_HOST: mysql
  DB_USER: root
  DB_PASSWORD: password
  DB_NAME: test_db

services:
  - mysql:8.0

before_script:
  - apt-get update -yqq
  - apt-get install -yqq git unzip libzip-dev zip libpng-dev libjpeg-dev
  - docker-php-ext-install zip pdo pdo_mysql
  - composer install --prefer-dist --no-progress --no-suggest
  - cp .env.example .env # Assuming you have environment file setup
  - sed -i "s/DB_HOST=.*/DB_HOST=${DB_HOST}/" .env
  - sed -i "s/DB_USERNAME=.*/DB_USERNAME=${DB_USER}/" .env
  - sed -i "s/DB_PASSWORD=.*/DB_PASSWORD=${DB_PASSWORD}/" .env
  - sed -i "s/DB_DATABASE=.*/DB_DATABASE=${DB_NAME}/" .env
  - php artisan key:generate
  - php artisan migrate --force # Use --force in CI for migrations

# Build stage (optional, for complex builds)
build_app:
  stage: build
  script:
    - echo "Building application..."
    # Add build steps here if necessary (e.g., compiling assets)

# Test stage
run_tests:
  stage: test
  script:
    - echo "Running tests..."
    - vendor/bin/phpunit --coverage-text --colors=never
    - vendor/bin/phpstan analyse src --level=max
  coverage: '/^\s*Lines:\s*\d+.\d+\%/'

# Deployment stage (example for staging)
deploy_staging:
  stage: deploy
  environment: staging
  script:
    - echo "Deploying to staging server..."
    # Add deployment commands here (e.g., rsync, SSH, Ansible)
    # Example: rsync -avz --delete ./public/ [email protected]:/var/www/html/
  only:
    - main # Deploy from the main branch

This service can be offered as a monthly retainer, ensuring the pipeline remains optimized and secure as the codebase evolves.

5. Cloud Infrastructure Management & Cost Optimization

Many e-commerce businesses are on cloud platforms (AWS, GCP, Azure) but often overspend or misconfigure their infrastructure. Offer a service to manage their cloud environment, focusing on scalability, reliability, and cost optimization. This includes setting up auto-scaling groups, optimizing instance types, implementing reserved instances or savings plans, and managing serverless architectures.

Example: AWS EC2 Cost Optimization Script (Python/Boto3)

import boto3
from datetime import datetime, timedelta

ec2 = boto3.client('ec2')
# For cost and usage reports, you might need AWS Cost Explorer API or CUR
# This example focuses on identifying underutilized instances

def find_underutilized_ec2_instances(threshold_cpu=10, threshold_network_in=10000, threshold_network_out=10000):
    """
    Identifies EC2 instances that might be underutilized based on CloudWatch metrics.
    Note: This is a simplified example. Real-world analysis requires more sophisticated metrics
    and longer observation periods.
    """
    underutilized = []
    # Get all running instances
    response = ec2.describe_instances(
        Filters=[{'Name': 'instance-state-name', 'Values': ['running']}]
    )

    for reservation in response['Reservations']:
        for instance in reservation['Instances']:
            instance_id = instance['InstanceId']
            instance_type = instance['InstanceType']
            launch_time = instance['LaunchTime']

            # Get metrics for the last 24 hours
            end_time = datetime.utcnow()
            start_time = end_time - timedelta(hours=24)

            try:
                # CPU Utilization
                cpu_metric = ec2.get_metric_statistics(
                    Namespace='AWS/EC2',
                    MetricName='CPUUtilization',
                    Dimensions=[{'Name': 'InstanceId', 'Value': instance_id}],
                    StartTime=start_time,
                    EndTime=end_time,
                    Period=3600, # Hourly
                    Statistics=['Average']
                )
                avg_cpu = cpu_metric['Datapoints'][0]['Average'] if cpu_metric['Datapoints'] else 100

                # Network In (Bytes)
                net_in_metric = ec2.get_metric_statistics(
                    Namespace='AWS/EC2',
                    MetricName='NetworkIn',
                    Dimensions=[{'Name': 'InstanceId', 'Value': instance_id}],
                    StartTime=start_time,
                    EndTime=end_time,
                    Period=3600,
                    Statistics=['Average']
                )
                avg_net_in = net_in_metric['Datapoints'][0]['Average'] if net_in_metric['Datapoints'] else 0

                # Network Out (Bytes)
                net_out_metric = ec2.get_metric_statistics(
                    Namespace='AWS/EC2',
                    MetricName='NetworkOut',
                    Dimensions=[{'Name': 'InstanceId', 'Value': instance_id}],
                    StartTime=start_time,
                    EndTime=end_time,
                    Period=3600,
                    Statistics=['Average']
                )
                avg_net_out = net_out_metric['Datapoints'][0]['Average'] if net_out_metric['Datapoints'] else 0

                if avg_cpu < threshold_cpu and avg_net_in < threshold_network_in and avg_net_out < threshold_network_out:
                    underutilized.append({
                        'InstanceId': instance_id,
                        'InstanceType': instance_type,
                        'AvgCPU': avg_cpu,
                        'AvgNetIn': avg_net_in,
                        'AvgNetOut': avg_net_out,
                        'LaunchTime': launch_time.isoformat()
                    })

            except Exception as e:
                print(f"Could not retrieve metrics for {instance_id}: {e}")

    return underutilized

if __name__ == "__main__":
    print("Searching for potentially underutilized EC2 instances...")
    potential_candidates = find_underutilized_ec2_instances()

    if potential_candidates:
        print("\n--- Potential Underutilized Instances ---")
        for candidate in potential_candidates:
            print(f"Instance ID: {candidate['InstanceId']}, Type: {candidate['InstanceType']}, "
                  f"Avg CPU: {candidate['AvgCPU']:.2f}%, Avg Net In: {candidate['AvgNetIn']:.2f} B/s, "
                  f"Avg Net Out: {candidate['AvgNetOut']:.2f} B/s, Launched: {candidate['LaunchTime']}")
        print("\nRecommendation: Investigate these instances further. Consider rightsizing or shutting down if not needed.")
    else:
        print("No significantly underutilized instances found based on current thresholds.")

This can be part of a monthly cloud health check and optimization service.

6. Data Migration & ETL Services

E-commerce businesses frequently need to migrate data between systems – from an old platform to a new one, from on-premise to cloud, or integrating data from various sources into a data warehouse. Offer specialized data migration and Extract, Transform, Load (ETL) services. This requires expertise in SQL, scripting languages (Python, Bash), and potentially ETL tools like Apache NiFi, Talend, or AWS Glue.

Example: Basic ETL Script for Customer Data (Python)

import pandas as pd
from sqlalchemy import create_engine

# --- Configuration ---
SOURCE_DB_CONNECTION_STRING = "postgresql://user:password@source_host:5432/source_db"
TARGET_DB_CONNECTION_STRING = "mysql+mysqlconnector://user:password@target_host:3306/target_db"
SOURCE_TABLE = "old_customers"
TARGET_TABLE = "customers"

# --- Extraction ---
def extract_data(connection_string, table_name):
    print(f"Extracting data from {table_name}...")
    try:
        engine = create_engine(connection_string)
        df = pd.read_sql_table(table_name, engine)
        print(f"Extracted {len(df)} records.")
        return df
    except Exception as e:
        print(f"Error during extraction: {e}")
        return None

# --- Transformation ---
def transform_data(df):
    print("Transforming data...")
    if df is None:
        return None

    # Rename columns
    df = df.rename(columns={
        "customer_id": "id",
        "first_name": "first_name",
        "last_name": "last_name",
        "email_address": "email",
        "created_at": "created_at",
        "updated_at": "updated_at"
    })

    # Clean email addresses
    df['email'] = df['email'].str.strip().str.lower()

    # Convert date formats if necessary (assuming they are already datetime objects from pandas)
    # Example: df['created_at'] = pd.to_datetime(df['created_at'])

    # Add new columns if needed
    df['source_system'] = 'legacy_platform'

    # Filter out invalid records (e.g., missing email)
    df = df.dropna(subset=['email'])
    df = df[df['email'].str.contains('@')] # Basic email validation

    print(f"Transformed {len(df)} records.")
    return df

# --- Loading ---
def load_data(df, connection_string, table_name):
    print(f"Loading data into {table_name}...")
    if df is None or df.empty:
        print("No data to load.")
        return

    try:
        engine = create_engine(connection_string)
        # Use 'append' to add new records, 'replace' to overwrite
        # Consider using 'if_exists='append'' and handling duplicates with unique constraints
        df.to_sql(table_name, engine, if_exists='append', index=False)
        print(f"Successfully loaded {len(df)} records into {table_name}.")
    except Exception as e:
        print(f"Error during loading: {e}")

# --- Main ETL Process ---
if __name__ == "__main__":
    # Extract
    raw_data = extract_data(SOURCE_DB_CONNECTION_STRING, SOURCE_TABLE)

    # Transform
    transformed_data = transform_data(raw_data)

    # Load
    load_data(transformed_data, TARGET_DB_CONNECTION_STRING, TARGET_TABLE)

    print("ETL process completed.")

This can be offered as a project-based service with a retainer for ongoing data synchronization or warehousing needs.

7. E-commerce Platform Migration & Upgrade Services

Businesses often outgrow their current e-commerce platform or need to migrate to a more robust solution (e.g., from Magento 1 to Magento 2, WooCommerce to Shopify Plus, or a custom solution). Offer end-to-end migration services. This involves planning, data migration (as above), theme/template conversion, extension/plugin porting, and post-migration testing and optimization. This is a high-value, project-based service that can lead to ongoing retainers for platform maintenance.

Example: Pre-migration Checklist Snippet (Conceptual)

# Pre-Migration Checklist: Magento 1 to Magento 2

## 1. Data Assessment & Cleansing
- [ ] Inventory all data entities: Products, Categories, Customers, Orders, CMS Pages, etc.
- [ ] Analyze data volume and complexity.
- [ ] Identify and cleanse duplicate or inconsistent data.
- [ ] Map M1 attributes/fields to M2 equivalents.
- [ ] Plan for historical data migration strategy (full vs. partial).

## 2. Extension/Module Audit
- [ ] List all M1 extensions currently in use.
- [ ] Check for M2 compatible versions or alternatives.
- [ ] Identify custom modules and assess porting effort.
- [ ] Prioritize essential extensions for migration.

## 3. Theme & Customizations
- [ ] Document current M1 theme structure and customizations.
- [ ] Plan for M2 theme development (Luma, Blank, or custom).
- [ ] Identify and document any custom frontend JavaScript or CSS.

## 4. Infrastructure & Environment
- [ ] Define M2 hosting requirements (PHP version, memory, database).
- [ ] Set up M2 staging environment.
- [ ] Configure necessary server software (Elasticsearch, Redis, Varnish).

## 5. Migration Strategy
- [ ] Choose migration tool (e.g., Magento Data Migration Tool, third-party tools).
- [ ] Plan migration phases: data, code, theme, configuration.
- [ ] Define rollback strategy.
- [ ] Schedule downtime window.

## 6. Testing Plan
- [ ] Unit tests for migrated code.
- [ ] Integration tests for core functionalities.
- [ ] User Acceptance Testing (UAT) plan.
- [ ] Performance testing.
- [ ] Security testing.

The complexity of these migrations justifies significant project fees, and the successful execution builds trust for future recurring services.

8. Performance Tuning & Optimization Retainer

Beyond initial audits, offer a continuous performance optimization retainer. This involves ongoing monitoring of key performance indicators (KPIs) like page load times, Time To First Byte (TTFB), Core Web Vitals, and server response times. Implement and tune caching layers (Varnish, Redis, CDN), optimize images, defer non-critical JavaScript, and fine-tune database configurations. This is a proactive approach to ensure the e-commerce site remains fast and responsive under varying traffic loads.

Example: Nginx Configuration for Caching & Optimization

# /etc/nginx/conf.d/ecommerce_site.conf

server {
    listen 80;
    server_name your-ecommerce-site.com;
    root /var/www/your-ecommerce-site/public; # Adjust to your public directory

    index index.php index.html index.htm;

    # Enable Gzip compression
    gzip on;
    gzip_vary on;
    gzip_proxied any;
    gzip_comp_level 6;
    gzip_types text/plain text/css application/json application/javascript text/xml application/xml application/xml+rss text/javascript image/svg+xml;

    # Browser Caching
    location ~* \.(css|js|jpg|jpeg|png|gif|ico|svg|webp|woff|woff2|ttf|eot)$ {
        expires 30d;
        add_header Cache-Control "public";
    }

    # Varnish Cache Integration (if using Varnish)
    # proxy_cache_path /var/cache/nginx levels=1:2 keys_zone=my_cache:10m max_size=10g inactive=60m use_temp_path=off;
    # proxy_cache my_cache;
    # proxy_cache_valid 200 302 10m;
    # proxy_cache_valid 404 1m;
    # proxy_cache_key "$scheme$request_method$host$request_uri";
    # proxy_pass http://127.0.0.1:8080; # Assuming Varnish is on port 8080

    # PHP processing (if using PHP-FPM)
    location ~ \.php$ {
        try_files $uri =404;
        fastcgi_split_path_info ^(.+\.php)(/.+)$;
        fastcgi_pass unix:/var/run/php/php8.1-fpm.sock; # Adjust PHP version
        fastcgi_index index.php;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        include fastcgi_params;

        # Add caching headers for PHP-generated content if applicable
        # add_header X-Cache-Status $upstream_cache_status; # If using proxy_cache
    }

    # Deny access to hidden files
    location ~ /\. {
        deny all;
        return 404;
    }

    # Serve static files directly
    location ~ ^/(images|javascript|js|css|flash|media|static)/ {
        try_files $uri =404;
    }

    # Prevent access to sensitive files
    location ~* (composer\.json|composer\.lock|\.env|\.git) {
        deny all;
    }

    # Handle 404s
    error_page 404 /index.php?route=error/not_found; # Example for OpenCart/similar CMS
    # For frameworks like Laravel/Symfony, usually handled by the framework itself.
}

This retainer ensures consistent high performance, directly impacting conversion rates and customer satisfaction.

9. Custom Feature Development & Plugin Creation

E-commerce businesses often require unique functionalities not available off-the-shelf. Offer custom feature development, building bespoke modules, plugins, or integrations tailored to their specific business needs. This could range from advanced product configurators, loyalty programs, custom checkout flows, to integrations with niche third-party tools. This service leverages your core development skills and can be billed hourly, per project, or via a retainer for ongoing development.

Example: Conceptual Outline for a Custom Product Bundle Plugin (WooCommerce/PHP)

<?php
/*
Plugin Name: Custom Product Bundles
Plugin URI: https://your-website.com/
Description: Allows creating product bundles with custom pricing and options.
Version: 1.0
Author: Your Name
Author URI: https://your-website.com/
License: GPL2
*/

// Prevent direct access
if ( ! defined( 'ABSPATH' ) ) {
    exit;
}

// --- 1. Define Custom Post Type for Bundles ---
function register_bundle_post_type() {
    $labels = array(
        'name'                  => _x( 'Bundles', 'Post Type General Name', 'text_domain' ),
        'singular_name'         => _x( 'Bundle', 'Post Type Singular Name', 'text_domain' ),
        'menu_name'             => __( 'Product Bundles', 'text_domain' ),
        'name_admin_bar'        => __( 'Bundle', 'text_domain' ),
        'archives'              => __( 'Bundle Archives', 'text_domain' ),
        'attributes'            => __( 'Bundle Attributes', 'text_domain' ),
        'parent_item_colon'     => __( 'Parent Bundle:', 'text_domain' ),
        'all_items'             => __( 'All Bundles', 'text_domain' ),
        'add_new_item'          => __( 'Add New Bundle', 'text_domain' ),
        'add_new'               => __( 'Add New', 'text_domain' ),
        'new_item'              => __( 'New Bundle', 'text_domain' ),
        'edit_item'             => __( 'Edit Bundle', 'text_domain' ),
        'update_item'           => __( 'Update Bundle', 'text_domain' ),
        'view_item'             => __( 'View Bundle', 'text_domain' ),
        'find_file'             => __( 'Find Bundle File', 'text_domain' ),
        'search_items'          => __( 'Search Bundle', 'text_domain' ),
        'not_found'             => __( 'Not found', 'text_domain' ),
        'not_found_in_trash'    => __( 'Not found in Trash', 'text_domain' ),
        'featured_image'        => __( 'Featured Image', 'text_domain' ),
        'set_featured_image'    => __( 'Set featured image', 'text_domain' ),
        'remove_featured_image' => __( 'Remove featured image', 'text_domain' ),
        'use_featured_image'    => __( 'Use as featured image', 'text_domain' ),
        'insert_into_file'      => __( 'Insert into bundle file', 'text_domain' ),
        'uploaded_to_this_file' => __( 'Uploaded to this bundle file', 'text_domain' ),
        'items_list'            => __( 'Bundles list', 'text_domain' ),
        'items_list_navigation' => __( 'Bundles list navigation', 'text_domain' ),
    );
    $args = array(
        'label'                 => __( 'Bundle', 'text_domain' ),
        'description'           => __( 'Custom Product Bundles', 'text_domain' ),
        'labels'                => $labels,
        'supports'              => array( 'title', 'editor', 'thumbnail' ),
        'hierarchical'          => false,
        'public'                => true,
        'show_ui'               => true,
        'show_in_menu'          => true,
        'menu_position'         => 5,
        'menu_icon'             => 'dashicons-cart',
        'show_in_admin_bar'     => true,
        'show_in_nav_menus'     => true,
        'can_export'            => true,
        'has_archive'           => true,
        'exclude_from_search'   => false,
        'publicly_queryable'    => true,
        'capability_type'       => 'post',
        'rewrite'               => array('slug' => 'product-bundle'),
    );
    register_post_type( 'product_bundle', $args );
}
add_action( 'init', 'register_bundle_post_type', 0 );

// --- 2. Add Metabox for Bundle Components ---
function add_bundle_components_metabox() {
    add_meta_box(
        'bundle_components',
        __( 'Bundle Components', 'text_domain' ),
        'render_bundle_components_metabox',
        'product_bundle',
        'normal',
        'high'
    );
}
add_action( 'add_meta_boxes', 'add_bundle_components_metabox' );

function render_bundle_components_metabox( $post ) {
    // Use nonce for verification
    wp_nonce_field( 'save_bundle_components_meta', 'bundle_components_nonce' );

    $components = get_post_meta( $post->ID, '_bundle_components', true );
    if ( ! is_array( $components ) ) {
        $components = array();
    }

    echo '<table class="widefat fixed">';
    echo '<thead><tr><th>' . __( 'Product ID', 'text_domain' ) . '</th><th>' . __( 'Quantity', 'text_domain' ) . '</th><th>' . __( 'Action', 'text_domain' ) . '</th></tr></thead>';
    echo '<tbody id="bundle-components-list">';

    if ( ! empty( $components ) ) {
        foreach ( $components as $index => $component ) {
            $product_id = isset( $component['product_id'] ) ? $component['product_id'] : '';
            $quantity = isset( $component['quantity'] ) ? $component['quantity'] : 1;
            echo '<tr>';
            echo '<td><input type="number" name="bundle_components[' . $index . '][product_id]" value="' . esc_attr( $product_id ) . '" placeholder="Product ID" required></td>';
            echo '<td><input type="number" name="bundle_components[' . $index . '][quantity]" value="' . esc_attr( $quantity ) . '" min="1" required></td>';
            echo '<td><button type="button" class="remove-component-row button">' . __( 'Remove', 'text_domain' ) . '</button></td>';
            echo '</tr>';
        }
    }

    echo '</tbody>';
    echo '</table>';
    echo '<button type="button" id="add-component-row" class="button button-secondary">' . __( 'Add Component', 'text_domain' ) . '</button>';

    // Add JavaScript for dynamic rows
    ?>
    <script type="text/javascript">
        jQuery(document).ready(function($) {
            $('#add-component-row').on('click', function() {
                var newRowIndex = $('#bundle-components-list tr').length;
                var newRow = '<tr>' +
                             '<td><input type="number" name="bundle_components[' + newRowIndex + '][product_id]" placeholder="Product ID" required></td>' +
                             '<td><input type="number" name="bundle_components[' + newRowIndex + '][quantity]" value="1" min="1" required></td>' +
                             '<td><button type="button" class="remove-component-row button">Remove</button></td>' +
                             '</tr&