Automating Shipping Workflows: From Order to Delivery Notification

Shipping Automation Overview

Manual shipping processes don't scale. Automating workflows from order receipt to delivery notification reduces errors, saves time, and improves customer experience.

Automation Architecture

Key Components

Order Import Automation

E-commerce Platform Integration

Order Webhook Handler

// Shopify order webhook
app.post('/webhooks/shopify/order', async (req, res) => {
  const order = req.body;
  // Validate webhook
  if (!verifyShopifyHmac(req)) {
    return res.status(401).send('Invalid');
  }
  // Queue for processing
  await orderQueue.add({
    orderId: order.id,
    platform: 'shopify',
    data: order
  });
  res.status(200).send('OK');
});

Batch Order Import

// Scheduled order import
const importOrders = async () => {
  const platforms = ['shopify', 'amazon', 'ebay'];
  for (const platform of platforms) {
    const orders = await fetchUnshippedOrders(platform);
    for (const order of orders) {
      await processOrder(order);
    }
  }
};
// Run every 15 minutes
cron.schedule('/15    *', importOrders);

Address Validation Automation

Validation Flow

const validateOrderAddress = async (order) => {
  const result = await addressApi.validate(order.shipping_address);
  if (result.valid) {
    // Use corrected address
    return {
      ...order,
      shipping_address: result.corrected_address,
      address_validated: true
    };
  }
  // Flag for manual review
  await flagForReview(order, 'invalid_address', result.errors);
  return null;
};

Address Correction Rules

Carrier Selection Automation

Rule-Based Selection

const selectCarrier = async (order) => {
  const rates = await shippingApi.getRates(order);
  // Apply business rules
  const filteredRates = rates.filter(rate => {
    // Weight restrictions
    if (order.weight > 70 && rate.carrier === 'usps') return false;
    // Service level requirements
    if (order.priority === 'express' && rate.days > 3) return false;
    // Carrier preferences
    if (order.destination.country !== 'US' && rate.carrier === 'usps') {
      return order.value < 100; // USPS for low-value international
    }
    return true;
  });
  // Sort by cost
  return filteredRates.sort((a, b) => a.rate - b.rate)[0];
};

Selection Criteria Matrix

Label Generation Automation

Automated Label Creation

const processOrderForShipping = async (order) => {
  try {
    // 1. Validate address
    const validatedOrder = await validateOrderAddress(order);
    if (!validatedOrder) return;
    // 2. Select carrier
    const selectedRate = await selectCarrier(validatedOrder);
    // 3. Create label
    const label = await shippingApi.createLabel({
      order: validatedOrder,
      rate: selectedRate
    });
    // 4. Update order with tracking
    await updateOrderTracking(order.id, {
      carrier: label.carrier,
      trackingNumber: label.tracking_number,
      labelUrl: label.label_url
    });
    // 5. Notify customer
    await sendShipmentNotification(order, label);
    return label;
  } catch (error) {
    await handleShippingError(order, error);
  }
};

Batch Label Processing

const processBatchLabels = async (orders) => {
  const results = {
    successful: [],
    failed: []
  };
  // Process in parallel with concurrency limit
  const chunks = chunkArray(orders, 10);
  for (const chunk of chunks) {
    const promises = chunk.map(order =>
      processOrderForShipping(order)
        .then(label => results.successful.push({ order, label }))
        .catch(error => results.failed.push({ order, error }))
    );
    await Promise.all(promises);
  }
  // Generate batch report
  return generateBatchReport(results);
};

Tracking and Status Updates

Webhook-Based Tracking

// Tracking webhook handler
app.post('/webhooks/tracking', async (req, res) => {
  const event = req.body;
  const order = await findOrderByTracking(event.tracking_number);
  switch (event.status) {
    case 'in_transit':
      await updateOrderStatus(order.id, 'shipped');
      break;
    case 'out_for_delivery':
      await sendDeliveryDayNotification(order);
      break;
    case 'delivered':
      await markOrderDelivered(order.id);
      await sendDeliveryConfirmation(order);
      break;
    case 'exception':
      await handleDeliveryException(order, event);
      break;
  }
  res.status(200).send('OK');
});

Polling Fallback

// For carriers without webhooks
const pollTrackingUpdates = async () => {
  const activeShipments = await getActiveShipments();
  for (const shipment of activeShipments) {
    const status = await shippingApi.getTracking(shipment.tracking_number);
    if (status.updated_at > shipment.last_update) {
      await processTrackingUpdate(shipment, status);
    }
  }
};
// Run every hour
cron.schedule('0    ', pollTrackingUpdates);

Customer Notification Automation

Notification Triggers

Email Template System

const sendShipmentNotification = async (order, label) => {
  const template = 'shipment_confirmation';
  await emailService.send({
    to: order.customer.email,
    template,
    data: {
      customerName: order.customer.name,
      orderNumber: order.number,
      trackingNumber: label.tracking_number,
      carrier: label.carrier,
      trackingUrl: generateTrackingUrl(label),
      estimatedDelivery: label.estimated_delivery,
      items: order.line_items
    }
  });
};

Error Handling and Recovery

Error Categories

Recovery Workflow

const handleShippingError = async (order, error) => {
  const errorType = classifyError(error);
  // Log error
  await logShippingError(order.id, error);
  // Determine action
  switch (errorType) {
    case 'retryable':
      await retryQueue.add({ orderId: order.id, attempt: 1 });
      break;
    case 'address_issue':
      await flagForManualReview(order.id, 'address_validation');
      break;
    case 'rate_error':
      await useBackupCarrier(order);
      break;
    default:
      await escalateToSupport(order.id, error);
  }
};

Atoship Automation Features

Start Automating Your Shipping

Create your Atoship account for automated shipping workflows with built-in integrations.