Order Fulfillment Workflow

Order Fulfillment Workflow

Overview

A fulfillment workflow takes a paid order from "awaiting fulfillment" through picking, packing, and shipping — with barcode verification to prevent mis-ships and packing slip generation for each shipment. For most merchants, purpose-built apps handle this more reliably and cheaply than custom software. Custom development only makes sense for high-volume operations with unique warehouse workflows.

When to Use This Skill

• When building internal warehouse tooling to replace manual spreadsheet-based picking processes
• When setting up a new fulfillment operation and need a structured workflow from day one
• When integrating with a third-party logistics (3PL) provider that requires a standardized order feed
• When adding pick verification to reduce mis-ships and customer complaints
• When you need to support both single-order picking and batch picking for efficiency

Core Instructions

Step 1: Determine your platform and choose the right fulfillment tool

Step 2: Set up your fulfillment tool

Shopify

Option A: ShipStation (recommended for 50+ orders/day)

1. Install ShipStation from the Shopify App Store 2. ShipStation automatically pulls all "unfulfilled" Shopify orders 3. Set up Automation Rules in ShipStation (Automation → Automation Rules) to assign carriers, services, and presets based on order weight, destination, or product type 4. Pick list: In ShipStation, go to Orders → select multiple orders → Print → Pick List. ShipStation generates a consolidated pick list sorted by your warehouse layout 5. Packing slips: Select orders → Print → Packing Slip. Customize the packing slip template in Account Settings → Printing → Document Templates 6. Label printing: ShipStation prints labels to a thermal label printer (Zebra, DYMO) via their desktop app — one scan per order creates and prints the label 7. After printing labels, ShipStation automatically marks orders as fulfilled in Shopify and sends tracking emails to customers

Option B: Shopify Fulfillment Network (SFN) — fully outsourced

1. Go to Settings → Shipping and delivery → Shopify Fulfillment Network 2. SFN handles all pick, pack, and ship operations — you ship your inventory to their warehouse and they fulfill orders automatically 3. No warehouse management needed on your end; SFN tracks inventory and fulfills orders same-day or next-day

Option C: Shopify's built-in fulfillment (for low volume)

1. Go to Orders → [Order] → Fulfill items 2. Enter the tracking number manually or purchase a label via Shopify Shipping 3. Shopify generates basic packing slips: Orders → Print → Packing slip

WooCommerce

Using ShipStation: 1. Install the ShipStation for WooCommerce plugin (free on WordPress.org) 2. In ShipStation, go to Account Settings → Stores and connect your WooCommerce store 3. Unfulfilled WooCommerce orders sync to ShipStation automatically 4. Use ShipStation for pick lists, packing slips, and label printing (same workflow as Shopify above) 5. When a label is printed, ShipStation pushes the tracking number back to WooCommerce and marks the order as "Completed"

WooCommerce-only (lower volume): 1. Install WooCommerce PDF Invoices & Packing Slips (free, WordPress.org) for PDF packing slips 2. Go to WooCommerce → Orders, select pending orders, and from the Bulk Actions dropdown choose "Generate packing slips" 3. For pick lists: the Smart Manager for WooCommerce plugin or ATUM Inventory Management generate pick lists directly from WooCommerce

BigCommerce

Using ShipStation: 1. Connect ShipStation via the BigCommerce App Marketplace 2. ShipStation syncs all open BigCommerce orders automatically 3. Use the same ShipStation workflow for pick lists, packing slips, and label printing

Using ShipBob (outsourced fulfillment): 1. Connect ShipBob from the BigCommerce App Marketplace 2. Ship your inventory to ShipBob warehouses; they fulfill all orders automatically 3. ShipBob updates BigCommerce order status and tracking in real time

Step 3: Configure pick list generation and warehouse workflow

A good pick list groups items by warehouse location (bin/shelf) to minimize picker travel time. Most shipping apps support this.

ShipStation pick list settings: 1. Go to Account Settings → Printing → Pick List 2. Configure grouping: by SKU (for batch picking) or by order (for single-order picking) 3. Enable "Show bin location" if you've entered bin locations on products (ShipStation → Products → edit product) 4. For barcode scanning: ShipStation has a Scan to Verify feature — enable it in Account Settings → Features. Scanners verify item barcodes before printing the label, preventing wrong-item fulfillment

For 3PL integration:

• Most 3PLs (ShipBob, Whiplash, Flexport) accept orders via EDI, SFTP CSV, or REST API
• In Shopify: install the 3PL's app or use a webhook to push orders to their system
• In WooCommerce: use a WooCommerce webhook (WooCommerce → Settings → Advanced → Webhooks) to push order data to the 3PL

Step 4: Set up carrier label creation

Shopify

• Shopify Shipping (built-in): purchase labels directly in Shopify admin from USPS, UPS, DHL, and Canada Post at discounted rates
• ShipStation: connects to all major carriers; negotiates rates based on your volume — often cheaper than Shopify Shipping for high-volume operations
• EasyShip: available on Shopify App Store; rate shops across 250+ carriers including international options

WooCommerce

• WooCommerce Shipping (built-in, powered by WooCommerce.com): USPS and DHL Express labels directly in the WooCommerce admin
• ShipStation plugin: connects to all major carriers from within ShipStation
• Easyship plugin: multi-carrier rate shopping directly in WooCommerce checkout and admin

BigCommerce

• ShipStation: rate shops all major carriers
• Easyship: native BigCommerce integration with 250+ carriers

Custom / Headless

import Shippo from 'shippo';
const shippo = Shippo(process.env.SHIPPO_API_KEY);

// Create a shipping label for a fulfilled order
async function createShippingLabel(params: {
  warehouseName: string;
  warehouseAddress: Address;
  customerAddress: Address;
  packageWeightOz: number;
  packageDimensions: { lengthIn: number; widthIn: number; heightIn: number };
  preferredService?: string;
}): Promise<{ trackingNumber: string; labelUrl: string }> {
  const shipment = await shippo.shipment.create({
    address_from: {
      name: params.warehouseName,
      street1: params.warehouseAddress.street1,
      city: params.warehouseAddress.city,
      state: params.warehouseAddress.state,
      zip: params.warehouseAddress.zip,
      country: 'US',
    },
    address_to: {
      name: params.customerAddress.name,
      street1: params.customerAddress.street1,
      city: params.customerAddress.city,
      state: params.customerAddress.state,
      zip: params.customerAddress.zip,
      country: params.customerAddress.country,
      email: params.customerAddress.email,
    },
    parcels: [{
      length: params.packageDimensions.lengthIn.toString(),
      width: params.packageDimensions.widthIn.toString(),
      height: params.packageDimensions.heightIn.toString(),
      distance_unit: 'in',
      weight: params.packageWeightOz.toString(),
      mass_unit: 'oz',
    }],
    async: false,
  });

  const rate = params.preferredService
    ? shipment.rates.find(r => r.servicelevel.token === params.preferredService)
    : shipment.rates.sort((a, b) => parseFloat(a.amount) - parseFloat(b.amount))[0];

  const transaction = await shippo.transaction.create({
    rate: rate.object_id,
    label_file_type: 'PDF',
  });

  return {
    trackingNumber: transaction.tracking_number,
    labelUrl: transaction.label_url,
  };
}

Best Practices

• Use a shipping app (ShipStation or equivalent) before building custom warehouse tooling — ShipStation costs $9–$159/month depending on volume and handles pick lists, packing slips, label printing, and carrier rate shopping; this is almost always cheaper and faster than custom development
• Sort pick lists by bin location — routing pickers through the warehouse in aisle/shelf order reduces picking time by 15–25%
• Send tracking numbers immediately after label creation — not when the carrier scans the package; customers who get tracking numbers sooner submit fewer "where is my order" tickets
• Verify scans at pick time — ShipStation's Scan to Verify and similar features prevent wrong-item shipments; enable this as a required step, not optional
• Print labels in batches at end of day — for sub-100 orders/day, batching label printing improves printer efficiency; for 100+ orders/day, print labels as orders are packed

Common Pitfalls

Related Skills

• @shipment-tracking
• @returns-management
• @order-management-system
• @international-shipping
• @dropshipping-integration

Shipping Label Creation and Carrier Integration

Problem/Feature Description

A growing direct-to-consumer brand ships roughly 500 packages per day from a single warehouse in Austin, TX. Their current process requires warehouse staff to log into a carrier portal, manually enter package dimensions, and copy-paste tracking numbers into the order system — a painful 3-minute-per-order process that often introduces errors. Customers also complain about not receiving tracking notifications until a day after their order ships.

The engineering team wants to automate label generation: as soon as a packed order is ready to ship, the system should call the carrier API, retrieve the right shipping rate, purchase a label, and immediately send the customer a tracking notification. The company uses multiple carriers (USPS, UPS, FedEx) and already stores the preferred service level on each order. The team wants to keep the database lean, so large label images should not be stored directly in the database.

Your task is to implement the shipping label creation module in TypeScript and write a brief architecture note explaining your approach.

Output Specification

Implement the following:

1. `shipping-label.ts` — Exports:

• A createShippingLabel(fulfillmentId: string): Promise<string> function that creates a carrier label and returns the label URL
• Any helper types or constants needed

2. `notify-customer.ts` — Exports:

• A sendTrackingNotification(orderId: string, trackingNumber: string, carrier: string): Promise<void> stub function (implementation can be a console.log or placeholder, but the function signature and call site must be correct)

3. `label-architecture.md` — A short note (200–400 words) covering:

• Which carrier API/SDK you chose and why
• How the rate selection works when multiple rates are returned
• What gets persisted to the database and what does not
• When the customer tracking notification is triggered

Assume a db object is available globally. Package credentials should come from environment variables. Install any npm packages needed.

Input Files

The following context file shows the relevant data model. Extract it before beginning.

=============== FILE: inputs/fulfillment-schema.ts =============== export interface Fulfillment { id: string; order_id: string; status: string; picker_id?: string; tracking_number?: string; carrier?: string; label_url?: string; package_length_in: number; package_width_in: number; package_height_in: number; package_weight_oz: number; created_at: Date; updated_at: Date; }

export interface Order { id: string; order_number: string; customer_id: string; customer_email: string; shipping_service: string; // carrier service level token, e.g. "usps_priority", "ups_ground" shipping_address: { first_name: string; last_name: string; line1: string; city: string; state: string; zip: string; country: string; }; created_at: Date; }

// Environment variables available at runtime: // process.env.SHIPPO_API_KEY // process.env.WAREHOUSE_NAME // process.env.WAREHOUSE_ADDRESS // process.env.WAREHOUSE_CITY // process.env.WAREHOUSE_STATE // process.env.WAREHOUSE_ZIP

Warehouse Picking System — State Management and Scan Verification

Problem/Feature Description

A mid-sized e-commerce company is replacing its spreadsheet-based warehouse operations with a proper fulfillment system. The company processes around 200 orders per day and has had repeated problems with pickers grabbing the wrong items or skipping lines in an order, resulting in angry customers and costly re-ships. They also have no audit trail when disputes arise.

The engineering team has decided to build a TypeScript-based warehouse management backend. Your job is to implement the core picking module: a fulfillment status system and a barcode scan verification API that warehouse staff will use on their mobile scanners. The module must track every state change and every scan in the database so that operations managers can investigate any fulfillment dispute.

Output Specification

Implement the following in TypeScript source files in the current directory:

1. `fulfillment-state.ts` — A module that exports:

• A FulfillmentStatus type (or enum) covering all stages of the fulfillment lifecycle from initial receipt through delivery
• A VALID_TRANSITIONS map or equivalent structure that prevents illegal status jumps
• A transitionFulfillment(fulfillmentId, newStatus, actorId) function that safely updates the status

2. `pick-verification.ts` — A module that exports:

• A verifyPickScan(fulfillmentId, orderLineId, scannedBarcode, pickedQuantity) function
• A markOrderFullyPicked(fulfillmentId, actorId) function
• An Express route handler (or plain function) for the mobile scanner HTTP endpoint

3. `fulfillment-module-plan.md` — A brief design document (300–500 words) describing:

• The status lifecycle you chose and why
• How scan verification works and what checks are performed
• How the audit trail is maintained
• Any concurrency or error-handling considerations

Assume the existence of a db object with collections: db.fulfillments, db.fulfillmentEvents, db.orderLines, db.products, db.pickVerifications. You do not need to implement the database layer itself — stub it as needed.

Input Files

The following context file describes the existing order data schema. Extract it before beginning.

=============== FILE: inputs/order-schema.ts =============== // Existing order data types already in the codebase

export interface Order { id: string; order_number: string; customer_id: string; customer_email: string; shipping_address: { first_name: string; last_name: string; line1: string; city: string; state: string; zip: string; country: string; }; shipping_service: string; // e.g. "usps_priority", "ups_ground" created_at: Date; }

export interface OrderLine { id: string; order_id: string; product_id: string; product_name: string; sku: string; quantity: number; }

export interface Product { id: string; sku: string; name: string; barcode: string; }

export interface Fulfillment { id: string; order_id: string; status: string; picker_id?: string; tracking_number?: string; carrier?: string; label_url?: string; package_length_in?: number; package_width_in?: number; package_height_in?: number; package_weight_oz?: number; created_at: Date; updated_at: Date; }

Warehouse Pick List and Packing Slip Service

Problem/Feature Description

A regional e-commerce fulfillment center handles both single-order and batch-order processing. The warehouse floor spans three aisles (A, B, C) with bin locations like "B2-07-3", and pickers currently receive poorly formatted printouts that send them back and forth across the warehouse. The operations director wants two improvements: first, a smarter pick list generator that groups routes efficiently; second, professionally formatted packing slips that can be printed server-side and physically placed in the box before sealing.

The tech lead has decided the packing slips must be generated on the backend (not in the browser) so they are reproducible and can be re-printed from the archive at any time. The team uses Node.js/TypeScript throughout. Your task is to implement both the pick list query logic and the packing slip generation service.

Output Specification

Implement the following TypeScript source files:

1. `pick-list.ts` — Exports:

• A generatePickList(orderIds: string[]) function that returns pick items for one or more orders
• A generateBatchPickList(orderIds: string[]) function suitable for collecting multiple orders in a single warehouse pass

2. `packing-slip.ts` — Exports:

• A generatePackingSlip(orderId: string): Promise<Buffer> function that produces a PDF document

3. `sample-output/` directory containing:

• `pick-list-sample.json` — A sample pick list output (with at least 3 items, realistic bin locations, realistic SKUs and barcodes)
• `batch-pick-list-sample.json` — A sample batch pick list output consolidating at least 2 orders

The TypeScript files should be complete enough to review the logic. Assume a db object is available globally with the same collections described in the schema below. Install any needed npm packages.

Input Files

The following schema file describes the data model. Extract it before beginning.

=============== FILE: inputs/schema.ts =============== export interface Order { id: string; order_number: string; customer_id: string; customer_email: string; shipping_address: { first_name: string; last_name: string; line1: string; city: string; state: string; zip: string; country: string; }; shipping_service: string; created_at: Date; }

export interface OrderLine { id: string; order_id: string; product_id: string; product_name: string; sku: string; quantity: number; }

export interface Product { id: string; sku: string; name: string; barcode: string; }

export interface WarehouseLocation { id: string; product_id: string; bin_location: string; // e.g. "A3-04-2" }

export interface Customer { id: string; name: string; email: string; }