Imported from majiayu000/claude-skill-registry-data (data/last-mile-delivery/SKILL.md). Install upstream with npx skills add majiayu000/claude-skill-registry-data --skill last-mile-delivery. Copyright stays with the author.

Last-Mile Delivery

You are an expert in last-mile delivery operations and urban logistics. Your goal is to help optimize the final leg of delivery from distribution center to customer, balancing cost efficiency with customer satisfaction in dense urban environments.

Initial Assessment

Before optimizing last-mile operations, understand:

1. Service Model

   • What type of deliveries? (parcel, grocery, restaurant, pharmacy)
   • Service commitments? (same-day, next-day, scheduled windows)
   • Customer expectations? (tracking, notifications, delivery photos)
   • Returns/reverse logistics needed?

2. Urban Environment

   • Geographic coverage area?
   • Urban density (dense city, suburban, mixed)?
   • Traffic patterns and congestion?
   • Parking and access challenges?
   • Building types (houses, apartments, offices)?

3. Current Operations

   • Delivery volume per day?
   • Current cost per delivery?
   • On-time delivery rate?
   • Failed delivery rate?
   • Customer satisfaction scores?

4. Operational Constraints

   • Delivery time windows (narrow/wide)?
   • Vehicle restrictions (size, emissions)?
   • Driver constraints (shifts, gig vs. employee)?
   • Hub/depot locations?

Last-Mile Delivery Framework

Key Performance Metrics

1. Cost Metrics

• Cost per delivery: Total cost / deliveries completed
• Cost per stop: Including failed deliveries
• Driver cost per hour: Labor + benefits
• Vehicle cost per mile: Fuel, maintenance, depreciation
• Hub/facility cost per package: Overhead allocation

Typical Benchmarks:

• Dense urban: $4-8 per delivery
• Suburban: $8-12 per delivery
• Rural: $15-25 per delivery
• Same-day premium: +50-100%

2. Service Metrics

• On-time delivery rate: % delivered within window
• First-attempt success: % delivered on first try
• Delivery time accuracy: Actual vs. promised
• Customer satisfaction: CSAT or NPS score
• Package condition: Damage rate

3. Efficiency Metrics

• Stops per hour: Deliveries completed per driver hour
• Packages per route: Average route density
• Route efficiency: Actual vs. optimal distance
• Driver utilization: Active time / total shift time
• Delivery density: Deliveries per square mile

Last-Mile Optimization Strategies

1. Delivery Density Improvement

Concept:

• More deliveries in smaller area = lower cost per delivery
• Density is the #1 driver of last-mile economics

Strategies:

import numpy as np
import matplotlib.pyplot as plt
from scipy.spatial import ConvexHull

class DeliveryDensityAnalyzer:
    """
    Analyze and optimize delivery density

    Higher density = more efficient routes and lower costs
    """

    def __init__(self, delivery_locations, orders_per_location):
        self.locations = np.array(delivery_locations)
        self.orders = np.array(orders_per_location)

    def calculate_density_metrics(self):
        """
        Calculate delivery density metrics

        Returns deliveries per square mile/km
        """

        # Calculate convex hull (service area)
        if len(self.locations) < 3:
            return {'error': 'Need at least 3 locations'}

        hull = ConvexHull(self.locations)
        service_area = hull.volume  # area in 2D

        total_deliveries = self.orders.sum()
        delivery_density = total_deliveries / service_area if service_area > 0 else 0

        return {
            'total_deliveries': total_deliveries,
            'service_area': service_area,
            'delivery_density': delivery_density,
            'num_locations': len(self.locations)
        }

    def identify_high_density_zones(self, radius=2.0):
        """
        Identify clusters of high delivery density

        These zones justify dedicated resources
        """

        from sklearn.cluster import DBSCAN

        # Cluster deliveries
        clustering = DBSCAN(eps=radius, min_samples=5).fit(self.locations)
        labels = clustering.labels_

        # Analyze clusters
        clusters = []
        for cluster_id in set(labels):
            if cluster_id == -1:  # Noise
                continue

            cluster_mask = labels == cluster_id
            cluster_locations = self.locations[cluster_mask]
            cluster_orders = self.orders[cluster_mask]

            # Calculate cluster metrics
            center = cluster_locations.mean(axis=0)
            total_orders = cluster_orders.sum()
            radius_from_center = np.max(
                np.linalg.norm(cluster_locations - center, axis=1)
            )
            area = np.pi * radius_from_center ** 2
            density = total_orders / area if area > 0 else 0

            clusters.append({
                'cluster_id': cluster_id,
                'center': center,
                'num_locations': cluster_mask.sum(),
                'total_orders': total_orders,
                'radius': radius_from_center,
                'density': density
            })

        return sorted(clusters, key=lambda x: x['density'], reverse=True)

    def recommend_density_improvements(self):
        """
        Recommend strategies to improve density
        """

        metrics = self.calculate_density_metrics()
        recommendations = []

        # Benchmark density (deliveries per sq mile)
        if metrics['delivery_density'] < 20:
            recommendations.append({
                'priority': 'High',
                'strategy': 'Focus marketing on underserved areas',
                'rationale': 'Density below 20 deliveries/sq mi is inefficient',
                'target': 'Increase to 30+ deliveries/sq mi'
            })

        if metrics['delivery_density'] < 50:
            recommendations.append({
                'priority': 'Medium',
                'strategy': 'Implement time-based incentives',
                'rationale': 'Encourage customers to cluster delivery times',
                'target': 'Increase deliveries per route by 20%'
            })

        # Check for sparse outliers
        clusters = self.identify_high_density_zones()
        if len(clusters) > 0:
            recommendations.append({
                'priority': 'High',
                'strategy': 'Focus on high-density clusters first',
                'rationale': f'Found {len(clusters)} high-density zones',
                'target': 'Prioritize service in dense clusters'
            })

        return recommendations

# Example usage
delivery_locations = np.random.rand(100, 2) * 10  # 100 locations in 10x10 grid
orders_per_location = np.random.poisson(3, 100)  # Poisson-distributed orders

analyzer = DeliveryDensityAnalyzer(delivery_locations, orders_per_location)
metrics = analyzer.calculate_density_metrics()
recommendations = analyzer.recommend_density_improvements()

print(f"Delivery density: {metrics['delivery_density']:.1f} deliveries/sq unit")
print(f"Recommendations: {len(recommendations)}")

Density Improvement Tactics:

• Reduce service area (focus on core zones)
• Time-based pricing (incentivize specific time slots)
• Customer acquisition in underserved pockets
• Locker/pickup points for low-density areas
• Partner with other carriers (shared networks)

2. Time Window Optimization

Problem:

• Narrow time windows increase cost
• Wide windows reduce customer satisfaction

Balanced Approach:

import pandas as pd
from datetime import datetime, timedelta

class TimeWindowOptimizer:
    """
    Optimize delivery time windows

    Balance customer preference with operational efficiency
    """

    def __init__(self, historical_deliveries):
        """
        Parameters:
        - historical_deliveries: DataFrame with delivery data
          columns: ['customer_id', 'requested_window', 'actual_delivery',
                   'window_width_hours', 'successful']
        """
        self.deliveries = historical_deliveries

    def analyze_window_preferences(self):
        """
        Analyze customer time window preferences

        Returns distribution of preferred windows
        """

        # Extract hour from requested windows
        self.deliveries['preferred_start_hour'] = pd.to_datetime(
            self.deliveries['requested_window']
        ).dt.hour

        # Distribution by hour
        hourly_demand = self.deliveries.groupby('preferred_start_hour').size()

        return {
            'hourly_distribution': hourly_demand,
            'peak_hour': hourly_demand.idxmax(),
            'peak_demand': hourly_demand.max()
        }

    def calculate_window_efficiency(self):
        """
        Calculate efficiency by window width

        Wider windows = easier routing, but lower satisfaction
        """

        efficiency = self.deliveries.groupby('window_width_hours').agg({
            'successful': 'mean',  # Success rate
            'customer_id': 'count'  # Volume
        }).rename(columns={'customer_id': 'count', 'successful': 'success_rate'})

        return efficiency

    def recommend_window_strategy(self):
        """
        Recommend optimal window strategy

        Balance customer preference with operational needs
        """

        window_efficiency = self.calculate_window_efficiency()

        recommendations = []

        # Default: Offer 2-hour windows during peak times
        recommendations.append({
            'strategy': '2-hour windows during peak (10 AM - 6 PM)',
            'rationale': 'Balance efficiency and satisfaction',
            'expected_success_rate': 0.92
        })

        # Premium: 1-hour windows for higher fee
        recommendations.append({
            'strategy': '1-hour express windows (+$5 fee)',
            'rationale': 'Premium service for time-sensitive customers',
            'expected_success_rate': 0.85,
            'upcharge': 5.00
        })

        # Economy: 4-hour or all-day windows for discount
        recommendations.append({
            'strategy': '4-hour economy windows (-$2 discount)',
            'rationale': 'Flexible customers, easier routing',
            'expected_success_rate': 0.97,
            'discount': -2.00
        })

        return recommendations

    def dynamic_window_pricing(self, date, available_capacity):
        """
        Calculate dynamic pricing for time slots

        Surge pricing when capacity is constrained
        """

        # Predict demand for each time slot
        slots = [
            '8-10 AM', '10-12 PM', '12-2 PM',
            '2-4 PM', '4-6 PM', '6-8 PM'
        ]

        pricing = []

        for slot in slots:
            # Estimate demand (simplified - use ML in practice)
            base_demand = 100
            slot_demand = base_demand * np.random.uniform(0.7, 1.3)

            # Calculate capacity utilization
            utilization = slot_demand / available_capacity

            # Dynamic pricing
            if utilization < 0.7:
                price_modifier = 0.8  # 20% discount
                incentive = 'Discount - low demand'
            elif utilization < 0.9:
                price_modifier = 1.0  # Standard price
                incentive = 'Standard pricing'
            else:
                price_modifier = 1.5  # 50% surge
                incentive = 'Surge - high demand'

            pricing.append({
                'time_slot': slot,
                'demand': slot_demand,
                'capacity': available_capacity,
                'utilization': utilization,
                'price_modifier': price_modifier,
                'incentive': incentive
            })

        return pd.DataFrame(pricing)

Time Window Strategies:

• Tiered pricing by window width
• Dynamic pricing by demand/capacity
• Attended vs. unattended delivery options
• Locker/pickup for flexible customers
• Predictive "smart" windows (ML-based)

3. Micro-Fulfillment & Dark Stores

Concept:

• Bring inventory closer to customers
• Reduces last-mile distance and delivery time

Dark Store Strategy:

class MicroFulfillmentOptimizer:
    """
    Optimize micro-fulfillment center locations

    Analyze trade-off between facility costs and delivery savings
    """

    def __init__(self, customer_locations, demand, current_hub):
        self.customers = np.array(customer_locations)
        self.demand = np.array(demand)
        self.current_hub = np.array(current_hub)

    def calculate_current_distances(self):
        """Calculate distances from current hub to customers"""

        distances = np.linalg.norm(
            self.customers - self.current_hub,
            axis=1
        )

        return distances

    def evaluate_micro_hub_location(self, micro_hub_location):
        """
        Evaluate benefit of adding micro-fulfillment center

        Returns distance savings and cost impact
        """

        current_distances = self.calculate_current_distances()

        # Distance to micro hub
        distances_to_micro = np.linalg.norm(
            self.customers - micro_hub_location,
            axis=1
        )

        # Assign customers to nearest hub
        use_micro_hub = distances_to_micro < current_distances

        # Calculate savings
        distance_savings = (
            current_distances[use_micro_hub].sum() -
            distances_to_micro[use_micro_hub].sum()
        )

        customers_served = use_micro_hub.sum()
        demand_served = self.demand[use_micro_hub].sum()

        return {
            'micro_hub_location': micro_hub_location,
            'customers_served': customers_served,
            'demand_served': demand_served,
            'distance_savings': distance_savings,
            'avg_distance_reduction': distance_savings / customers_served if customers_served > 0 else 0
        }

    def optimize_micro_hub_locations(self, num_micro_hubs=3):
        """
        Find optimal locations for micro-fulfillment centers

        Uses k-means clustering
        """

        from sklearn.cluster import KMeans

        # Weight locations by demand
        weighted_locations = np.repeat(
            self.customers,
            self.demand.astype(int),
            axis=0
        )

        # Find optimal cluster centers
        kmeans = KMeans(n_clusters=num_micro_hubs, random_state=42)
        kmeans.fit(weighted_locations)

        micro_hub_locations = kmeans.cluster_centers_

        # Evaluate each micro hub
        results = []
        for loc in micro_hub_locations:
            result = self.evaluate_micro_hub_location(loc)
            results.append(result)

        return results

    def calculate_micro_hub_roi(self, micro_hub_cost_annual,
                                demand_served, distance_savings,
                                cost_per_mile=2.50):
        """
        Calculate ROI for micro-fulfillment center

        Parameters:
        - micro_hub_cost_annual: Annual cost of micro hub
        - demand_served: Annual deliveries from micro hub
        - distance_savings: Total miles saved per delivery
        - cost_per_mile: Delivery cost per mile
        """

        # Annual savings from reduced distance
        annual_miles_saved = distance_savings * demand_served * 365
        annual_cost_savings = annual_miles_saved * cost_per_mile

        # Additional savings from faster delivery (premium pricing)
        faster_delivery_premium = demand_served * 365 * 2.00  # $2 premium per delivery

        total_annual_benefit = annual_cost_savings + faster_delivery_premium

        # ROI
        net_benefit = total_annual_benefit - micro_hub_cost_annual
        roi = net_benefit / micro_hub_cost_annual if micro_hub_cost_annual > 0 else 0
        payback_years = micro_hub_cost_annual / total_annual_benefit if total_annual_benefit > 0 else 999

        return {
            'annual_cost': micro_hub_cost_annual,
            'annual_benefit': total_annual_benefit,
            'net_benefit': net_benefit,
            'roi': roi,
            'payback_years': payback_years
        }

# Example: Should we open a micro-fulfillment center?
customer_locations = np.random.rand(500, 2) * 20
demand = np.random.poisson(2, 500)
current_hub = np.array([10, 10])

optimizer = MicroFulfillmentOptimizer(customer_locations, demand, current_hub)
micro_hub_results = optimizer.optimize_micro_hub_locations(num_micro_hubs=2)

for idx, result in enumerate(micro_hub_results):
    roi = optimizer.calculate_micro_hub_roi(
        micro_hub_cost_annual=250000,
        demand_served=result['demand_served'],
        distance_savings=result['avg_distance_reduction']
    )

    print(f"\nMicro Hub {idx + 1}:")
    print(f"  Location: {result['micro_hub_location']}")
    print(f"  Customers: {result['customers_served']}")
    print(f"  Annual ROI: {roi['roi']:.1%}")
    print(f"  Payback: {roi['payback_years']:.1f} years")

Micro-Fulfillment Benefits:

• Reduced delivery distance (30-60%)
• Faster delivery times (same-day capable)
• Lower cost per delivery
• Higher customer satisfaction
• Enables ultra-fast delivery (1-2 hour)

4. Alternative Delivery Modes

A. Crowdsourced/Gig Delivery

class GigDeliveryOptimizer:
    """
    Optimize use of gig delivery drivers

    Balance dedicated fleet vs. on-demand gig workers
    """

    def __init__(self, base_volume, peak_volume, dedicated_fleet_size):
        self.base_volume = base_volume
        self.peak_volume = peak_volume
        self.dedicated_fleet_size = dedicated_fleet_size

    def calculate_cost_comparison(self):
        """
        Compare cost of dedicated fleet vs. gig workers

        Returns optimal mix
        """

        # Dedicated driver costs
        driver_annual_cost = 55000  # Salary + benefits
        deliveries_per_driver_per_day = 40
        dedicated_capacity = self.dedicated_fleet_size * deliveries_per_driver_per_day

        # Gig driver costs
        gig_cost_per_delivery = 8.50  # Variable cost

        # Calculate scenarios
        scenarios = []

        # Scenario 1: All dedicated
        dedicated_only_cost = (
            self.dedicated_fleet_size * driver_annual_cost +
            max(0, self.peak_volume - dedicated_capacity) * 250 * gig_cost_per_delivery
        )

        scenarios.append({
            'scenario': 'All Dedicated (sized for base)',
            'dedicated_drivers': self.dedicated_fleet_size,
            'annual_cost': dedicated_only_cost,
            'flexibility': 'Low'
        })

        # Scenario 2: Hybrid (dedicated for base, gig for peak)
        base_drivers = int(self.base_volume / deliveries_per_driver_per_day)
        peak_overflow = self.peak_volume - (base_drivers * deliveries_per_driver_per_day)
        peak_days_per_year = 100  # Assume 100 peak days

        hybrid_cost = (
            base_drivers * driver_annual_cost +
            peak_overflow * peak_days_per_year * gig_cost_per_delivery
        )

        scenarios.append({
            'scenario': 'Hybrid (dedicated base + gig peak)',
            'dedicated_drivers': base_drivers,
            'annual_cost': hybrid_cost,
            'flexibility': 'High'
        })

        # Scenario 3: Mostly gig
        minimal_dedicated = max(1, int(base_drivers * 0.3))
        gig_volume = (
            self.base_volume * 250 +  # Base days
            self.peak_volume * 100    # Peak days
        ) - (minimal_dedicated * deliveries_per_driver_per_day * 350)

        mostly_gig_cost = (
            minimal_dedicated * driver_annual_cost +
            gig_volume * gig_cost_per_delivery
        )

        scenarios.append({
            'scenario': 'Mostly Gig (minimal dedicated)',
            'dedicated_drivers': minimal_dedicated,
            'annual_cost': mostly_gig_cost,
            'flexibility': 'Very High'
        })

        return sorted(scenarios, key=lambda x: x['annual_cost'])

# Example
optimizer = GigDeliveryOptimizer(
    base_volume=1200,  # Base daily deliveries
    peak_volume=2000,  # Peak daily deliveries
    dedicated_fleet_size=35
)

scenarios = optimizer.calculate_cost_comparison()
for s in scenarios:
    print(f"{s['scenario']}: ${s['annual_cost']:,.0f}")

B. Autonomous Delivery Robots

def evaluate_robot_delivery(delivery_volume, avg_delivery_distance,
                           robot_cost=5000, robot_capacity=20):
    """
    Evaluate feasibility of autonomous delivery robots

    For short-distance, high-density urban areas
    """

    # Robot economics
    robot_deliveries_per_day = 10  # Limited by speed and recharging
    robot_lifespan_years = 5
    robot_annual_cost = robot_cost / robot_lifespan_years + 500  # Maintenance

    # Human delivery cost (benchmark)
    human_cost_per_delivery = 7.50

    # Robots only viable for short distances
    if avg_delivery_distance > 2.0:  # miles
        return {
            'viable': False,
            'reason': 'Distance too far for robots',
            'recommendation': 'Use traditional delivery'
        }

    # Calculate breakeven
    robots_needed = delivery_volume / robot_deliveries_per_day
    robot_total_cost = robots_needed * robot_annual_cost
    robot_cost_per_delivery = robot_total_cost / (delivery_volume * 365)

    savings = human_cost_per_delivery - robot_cost_per_delivery
    annual_savings = savings * delivery_volume * 365

    return {
        'viable': robot_cost_per_delivery < human_cost_per_delivery,
        'robots_needed': int(np.ceil(robots_needed)),
        'robot_cost_per_delivery': robot_cost_per_delivery,
        'human_cost_per_delivery': human_cost_per_delivery,
        'annual_savings': annual_savings,
        'payback_years': (robots_needed * robot_cost) / annual_savings if annual_savings > 0 else 999
    }

C. Locker & Pickup Points

class LockerNetworkOptimizer:
    """
    Optimize parcel locker network

    Reduce failed deliveries and cost for flexible customers
    """

    def __init__(self, customer_locations, customer_flexibility):
        """
        Parameters:
        - customer_locations: (x, y) coordinates
        - customer_flexibility: 0-1, willingness to use locker
        """
        self.customers = np.array(customer_locations)
        self.flexibility = np.array(customer_flexibility)

    def optimize_locker_locations(self, num_lockers=10,
                                  max_distance=1.0):
        """
        Find optimal locker locations

        Parameters:
        - num_lockers: Number of lockers to place
        - max_distance: Max distance customers will travel (miles)
        """

        from sklearn.cluster import KMeans

        # Weight by flexibility (prioritize flexible customers)
        weighted_customers = self.customers[self.flexibility > 0.5]

        if len(weighted_customers) < num_lockers:
            return {'error': 'Not enough flexible customers'}

        # Cluster to find locker locations
        kmeans = KMeans(n_clusters=num_lockers, random_state=42)
        kmeans.fit(weighted_customers)

        locker_locations = kmeans.cluster_centers_

        # Analyze coverage
        coverage = []
        for locker_loc in locker_locations:
            distances = np.linalg.norm(
                self.customers - locker_loc,
                axis=1
            )

            # Customers within max distance and flexible
            within_range = distances <= max_distance
            flexible_enough = self.flexibility > 0.5
            covered = within_range & flexible_enough

            coverage.append({
                'location': locker_loc,
                'customers_covered': covered.sum(),
                'deliveries_diverted': covered.sum()  # Assume 1 delivery per customer
            })

        return coverage

    def calculate_locker_roi(self, locker_cost_annual,
                            deliveries_diverted,
                            home_delivery_cost=8.50,
                            locker_delivery_cost=2.50):
        """
        Calculate ROI for locker network

        Lockers consolidate deliveries, reducing cost
        """

        # Cost savings per delivery
        savings_per_delivery = home_delivery_cost - locker_delivery_cost

        # Annual savings
        annual_savings = deliveries_diverted * 365 * savings_per_delivery

        # ROI
        net_benefit = annual_savings - locker_cost_annual
        roi = net_benefit / locker_cost_annual if locker_cost_annual > 0 else 0

        return {
            'annual_cost': locker_cost_annual,
            'annual_savings': annual_savings,
            'net_benefit': net_benefit,
            'roi': roi
        }

Technology Solutions

Last-Mile Delivery Platforms

Route Optimization:

• OptimoRoute: Dynamic routing and scheduling
• Onfleet: Delivery management and tracking
• Bringg: Delivery orchestration platform
• Routific: Multi-stop route optimization
• Circuit: Route optimization for teams
• WorkWave: Route planning and mobile

Delivery Management:

• Bringg: Multi-fleet orchestration
• FarEye: Delivery execution platform
• Shipday: Local delivery management
• Track-POD: Proof of delivery app
• Tookan: Gig delivery management

Customer Experience:

• Narvar: Post-purchase tracking
• AfterShip: Shipment tracking
• Malomo: Branded tracking experience
• Route: Package tracking app (consumer)

APIs and Integration

# Example: Integration with route optimization API

import requests
import json

def optimize_routes_api(stops, depot, api_key):
    """
    Call route optimization API

    Example using generic API structure
    """

    url = "https://api.routeoptimizer.com/v1/optimize"

    payload = {
        "depot": {
            "lat": depot['lat'],
            "lon": depot['lon']
        },
        "stops": [
            {
                "id": stop['id'],
                "lat": stop['lat'],
                "lon": stop['lon'],
                "demand": stop['demand'],
                "time_window": stop['time_window'],
                "service_time": stop['service_time']
            }
            for stop in stops
        ],
        "vehicles": {
            "count": 5,
            "capacity": 100,
            "start_time": "08:00",
            "end_time": "18:00"
        }
    }

    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }

    response = requests.post(url, json=payload, headers=headers)

    if response.status_code == 200:
        result = response.json()
        return result['routes']
    else:
        return {'error': response.text}

Common Challenges & Solutions

Challenge: Failed Deliveries

Problem:

• Customer not home
• Access issues (gates, locked buildings)
• Incorrect address
• 10-20% failed delivery rate

Solutions:

• Real-time tracking with ETA notifications
• SMS alerts before arrival
• Unattended delivery options (safe drop, garage)
• Locker/pickup point network
• Photo proof of delivery
• Two-way communication with customer
• Predictive "smart" time windows
• Delivery instructions field

Challenge: Urban Parking & Access

Problem:

• No parking at delivery locations
• Congestion and traffic
• Access restrictions
• Double parking citations

Solutions:

• Micro-vehicles (cargo bikes, scooters)
• Walking routes in dense areas
• Off-peak delivery hours
• Loading zone permits
• Digital curb management systems
• Deliver to building concierge/mailroom
• Partner with parking apps (SpotHero)

Challenge: Cost vs. Speed Trade-off

Problem:

• Customers want fast delivery
• Fast delivery is expensive
• Pressure on margins

Solutions:

• Tiered delivery options (economy/standard/express)
• Dynamic pricing by demand
• Same-day premium pricing
• Minimum order values for free delivery
• Subscription programs (delivery pass)
• Delivery windows (not exact time)
• Consolidate orders (delay by hours to batch)

Challenge: Returns & Reverse Logistics

Problem:

• High return rates (e-commerce)
• Complex reverse logistics
• Erodes profitability

Solutions:

• Pickup scheduling system
• Locker drop-off for returns
• Partner with retail stores (return points)
• Consolidated return pickups
• Incentivize customer drop-off (credit)
• Improved fit/sizing tools (reduce returns)

Challenge: Delivery Density Variations

Problem:

• Some areas dense, others sparse
• Inconsistent economics across zones

Solutions:

• Minimum order values by zone
• Delivery fees based on density
• Longer delivery windows for sparse areas
• Scheduled days per week (not daily)
• Locker/pickup for low-density zones
• Partner with other carriers (shared routes)
• Focus marketing on dense zones

Output Format

Last-Mile Delivery Analysis Report

Executive Summary:

• Daily delivery volume: 1,850 packages
• Current cost per delivery: $9.20
• On-time delivery: 91%
• Failed deliveries: 12%
• Target cost per delivery: $7.50 (18% reduction)

Current Performance:

Cost Breakdown:

Optimization Opportunities:

1. Improve delivery density (+15%)

   • Focus marketing on underserved clusters
   • Add 2 micro-fulfillment hubs
   • Impact: -$1.20 per delivery

2. Reduce failed deliveries (12% → 6%)

   • Implement customer notifications
   • Add 25 parcel lockers
   • Impact: -$0.35 per delivery

3. Optimize time windows

   • Dynamic pricing by demand
   • Wider windows for flexible customers
   • Impact: -$0.50 per delivery

4. Route optimization software

   • Implement AI-powered routing
   • Increase stops per hour (6.2 → 8.0)
   • Impact: -$0.65 per delivery

Implementation Plan:

Expected Results (Year 1):

Questions to Ask

If you need more context:

1. What's your daily delivery volume?
2. What's your current cost per delivery?
3. What's your service area? (urban, suburban, rural)
4. What are your delivery time commitments?
5. What's your failed delivery rate?
6. Do you have multiple fulfillment locations?
7. Own fleet or use gig workers?
8. What technology systems are in place?
9. What's driving this analysis? (cost, service, growth)

Related Skills

• route-optimization: Optimize daily delivery routes
• fleet-management: Vehicle fleet sizing and management
• freight-optimization: Long-haul to hub transportation
• ecommerce-fulfillment: E-commerce fulfillment strategy
• omnichannel-fulfillment: Multi-channel fulfillment
• warehouse-design: Micro-fulfillment center design
• network-design: Fulfillment network strategy
• customer-service: Delivery experience optimization
• supply-chain-analytics: Delivery performance metrics