How Dynamic QR Codes Are Driving 40% Higher ROI for Marketing Campaigns in 2025

// Step 1: Generate a dynamic QR code
const generateDynamicQR = async (campaignId, destinationUrl) => {
  const response = await moduleAppClient.v1GenerateQrCode.v1GenerateQrCodeAction({
    data: destinationUrl, // This will be your redirect service URL
    size: 300,
    format: 'png',
    errorCorrection: 'M',
    margin: 4
  });

  // Store the QR code ID with campaign metadata
  await saveQRCodeToDatabase({
    qrId: response.qrCodeId,
    campaignId,
    originalDestination: destinationUrl,
    currentDestination: destinationUrl,
    createdAt: new Date(),
    scans: 0,
    uniqueScans: 0
  });

  return response.qrCodeImage;
};

// Step 2: Create the redirect handler
app.get('/qr/:qrId', async (req, res) => {
  const { qrId } = req.params;
  const userAgent = req.get('User-Agent');
  const ip = req.ip;

  try {
    // Get QR code details and analytics
    const qrData = await getQRCodeFromDatabase(qrId);

    if (!qrData) {
      return res.status(404).send('QR code not found');
    }

    // Track the scan
    await trackQRScan({
      qrId,
      timestamp: new Date(),
      ip,
      userAgent,
      location: await getLocationFromIP(ip),
      device: parseDeviceType(userAgent)
    });

    // Apply business rules for destination
    const finalDestination = await applyBusinessRules(qrData, req);

    // Redirect to final destination
    res.redirect(302, finalDestination);

  } catch (error) {
    console.error('QR redirect error:', error);
    res.status(500).send('Internal server error');
  }
});

// Step 3: Business rules engine
const applyBusinessRules = async (qrData, request) => {
  const { timeOfDay, device, location } = request;
  const { currentDestination, campaignRules } = qrData;

  // Time-based routing
  if (campaignRules.timeBasedRedirects) {
    const hour = new Date().getHours();
    if (hour >= 6 && hour < 12) {
      return campaignRules.morningDestination || currentDestination;
    } else if (hour >= 12 && hour < 18) {
      return campaignRules.afternoonDestination || currentDestination;
    } else {
      return campaignRules.eveningDestination || currentDestination;
    }
  }

  // Location-based routing
  if (campaignRules.locationBasedRedirects && location) {
    const locationRule = campaignRules.locationRules.find(
      rule => isLocationInRadius(location, rule.center, rule.radius)
    );
    if (locationRule) {
      return locationRule.destination;
    }
  }

  // Device-specific routing
  if (campaignRules.deviceBasedRedirects) {
    if (device.type === 'mobile' && campaignRules.mobileDestination) {
      return campaignRules.mobileDestination;
    } else if (device.type === 'desktop' && campaignRules.desktopDestination) {
      return campaignRules.desktopDestination;
    }
  }

  return currentDestination;
};

# Advanced QR Analytics Pipeline
import pandas as pd
import plotly.graph_objects as go
from datetime import datetime, timedelta

class QRAnalytics:
    def __init__(self, database_connection):
        self.db = database_connection

    def getCampaignMetrics(self, campaignId, days=30):
        """Get comprehensive campaign performance metrics"""

        # Base metrics
        total_scans = self.db.query("""
            SELECT COUNT(*) as scans
            FROM qr_scans
            WHERE campaign_id = %s
            AND created_at >= %s
        """, (campaignId, datetime.now() - timedelta(days=days)))

        unique_scans = self.db.query("""
            SELECT COUNT(DISTINCT ip_address) as unique_scans
            FROM qr_scans
            WHERE campaign_id = %s
            AND created_at >= %s
        """, (campaignId, datetime.now() - timedelta(days=days)))

        # Time-based analysis
        hourly_scans = self.db.query("""
            SELECT EXTRACT(HOUR FROM created_at) as hour, COUNT(*) as scans
            FROM qr_scans
            WHERE campaign_id = %s
            AND created_at >= %s
            GROUP BY EXTRACT(HOUR FROM created_at)
            ORDER BY hour
        """, (campaignId, datetime.now() - timedelta(days=days)))

        # Geographic analysis
        location_data = self.db.query("""
            SELECT country, city, COUNT(*) as scans
            FROM qr_scans
            WHERE campaign_id = %s
            AND created_at >= %s
            GROUP BY country, city
            ORDER BY scans DESC
            LIMIT 20
        """, (campaignId, datetime.now() - timedelta(days=days)))

        # Device analysis
        device_data = self.db.query("""
            SELECT device_type, COUNT(*) as scans
            FROM qr_scans
            WHERE campaign_id = %s
            AND created_at >= %s
            GROUP BY device_type
        """, (campaignId, datetime.now() - timedelta(days=days)))

        return {
            'total_scans': total_scans[0]['scans'],
            'unique_scans': unique_scans[0]['unique_scans'],
            'scan_rate': total_scans[0]['scans'] / days,
            'unique_scan_rate': unique_scans[0]['unique_scans'] / days,
            'hourly_distribution': hourly_scans,
            'top_locations': location_data,
            'device_breakdown': device_data
        }

    def generateROIReport(self, campaignId, campaignCost, conversionValue):
        """Calculate detailed ROI metrics"""
        metrics = self.getCampaignMetrics(campaignId)

        # Cost per scan
        cost_per_scan = campaignCost / metrics['total_scans']
        cost_per_unique_scan = campaignCost / metrics['unique_scans']

        # Conversion tracking (assumes conversion tracking is implemented)
        conversions = self.db.query("""
            SELECT COUNT(*) as conversions
            FROM conversion_events
            WHERE campaign_id = %s
            AND created_at >= %s
        """, (campaignId, datetime.now() - timedelta(days=30)))

        conversion_rate = conversions[0]['conversions'] / metrics['unique_scans']
        conversion_revenue = conversions[0]['conversions'] * conversionValue

        # ROI calculations
        roi = (conversion_revenue - campaignCost) / campaignCost * 100

        return {
            'campaign_cost': campaignCost,
            'total_scans': metrics['total_scans'],
            'unique_scans': metrics['unique_scans'],
            'cost_per_scan': cost_per_scan,
            'cost_per_unique_scan': cost_per_unique_scan,
            'conversions': conversions[0]['conversions'],
            'conversion_rate': conversion_rate,
            'conversion_revenue': conversion_revenue,
            'roi_percentage': roi
        }