The Merchant Playbook: Shipping at Scale

Shipping works... until it doesn't.

For most merchants, the process feels manageable at first. Orders come in, labels get created, packages go out. It's not perfect, but it works.

Then something changes. A sales campaign performs better than expected. A seasonal spike hits. A partner drops a list of hundreds or thousands of shipments that need to go out quickly. What used to take an hour now takes a full day. Small inefficiencies stack, formatting issues creep in, manual steps multiply, and suddenly shipping isn't just a task, it's a bottleneck. And when shipping breaks, customers feel it immediately.

However, when the post-purchase operating layer is built well, merchants get clarity, visibility, and control under pressure and customers get a better customer experience after checkout.

This post is a practical playbook for building that operating layer before the next spike hits. Here's the core concept: shipping at scale isn't a checklist of tasks, it's a designed post-purchase operating layer.

Why Shipping Breaks at Scale

Shipping typically fails because the workflow wasn't designed for volume.

At low order counts, manual work is easy to keep up with:

Cleaning up spreadsheets
Copying and pasting addresses
Creating labels one at a time

But these steps don't scale linearly, they compound. Think about it this way: At 50 shipments, a 30-second manual step is annoying. At 5,000 shipments, that same step becomes 40+ labor hours, and that's before you count the "restart cost" when a rigid import fails and you have to redo work. This is why the real problem is rarely "shipping speed." It's variability, rework, and exception handling especially during spikes.

We've seen this play out firsthand. When AirBaton was tasked with fulfilling roughly 4,500-5,000 shipments for a national campaign, the bottleneck wasn't printing labels, it was the friction upstream. Their previous tools made bulk uploads difficult, required very specific spreadsheet formats, and small errors could force a restart.

Once the data import process was standardized and label creation moved into batches (including printing 250 labels at once), the work became far more manageable under pressure. The downstream result was fewer restarts, faster throughput, and a calmer fulfillment week.

The 6-Step Shipping Workflow

The difference isn't putting more effort into the workflow. It's structure. The goal isn't to work harder during peak moments. It's to build a post-purchase operating layer that gives you control when volume spikes so that your team isn't improvising, and your customers aren't wondering what's happening with their order.

A simple "default workflow" many merchants aim for:

Intake: Standardize data
Validate: Catch issues early
Default: Apply service + packaging rules
Batch + Automate: Batch create labels, bulk print, handoff to the carrier
Exceptions: Handle independently and quickly for fast resolution
Communication: Transparent tracking and customer updates

This structure creates clarity about what's ready, visibility into what's stuck, and control over what happens next.

1 - Standardize Order Intake for Clarity

Everything downstream depends on clean, consistent data upstream. Merchants that struggle often spend more time fixing order and shipment data than fulfilling orders:

Reformatting CSVs
Correcting address fields
Dealing with import errors
Rebuilding a batch when a rigid upload fails

The fix isn't more effort, it's removing variability by:

Using a system that accepts data from varied sources and formats
Using direct integrations with sales channels and marketplaces when possible
Minimizing manual handling of raw data. Copying and pasting is a hidden tax
Accepting ship-to lists in the format they arrive in and mapping imports once instead of reformatting every file

Concrete outcome to aim for:

If a partner sends a spreadsheet in their format, your process should be:

Map the import once > Save mapping > Import > Reuse mapping for all future imports for this partner

This process avoids: Reformat for an hour > attempt upload > restart if it fails

2 - Validate Before You Create Labels

A lot of shipping chaos is actually data issues that are discovered too late. Validation is how you avoid generating 500 labels then realizing 30 shipments are missing required information or have incorrect or improperly formatted addresses.

Use validation to:

Verify Ship To Addresses: Mistakes happen. Utilize built-in address lookup to correct incorrectly entered addresses.
Check for missing required fields: Name, street, city, postal, country, phone when required, etc.
Verify all shipment details are correct: Are weights, dimensions, package type, carrier and service information correct so labels are created correctly, the first time?
Check for duplicate orders or duplicate labels: Prevent costly duplicate shipments.

This is one of the highest-ROI forms of automation: automate the checks so humans only touch the edge cases.

3 - Apply Defaults, Rules, and Carrier Flexibility (A Decision Anchor)

Shipping isn't just about getting packages out. It's about making repeatable tradeoffs between cost, speed, reliability, and customer expectations. The missing piece in most workflows isn't "more options." It's a decision anchor.

Definition: A decision anchor is the default shipping choice you can run on autopilot with confidence, plus the minimal set of rules that tells you when to override it.

Here's a simple decision anchor merchants often implement:

Default Service

Define the default service that covers the majority of your orders.

Add three override rules

Promise rule to meet customer expectation: If the customer paid for expedited, or a delivery window is promised, use the required service.
Risk rule: If an order's value is above a defined threshold, add signature required and/or insurance and use the carrier/service that supports it reliably.
Cost guardrail: If the shipping cost exceeds a set percentage of the order's value, or exceeds a fixed threshold, route to exceptions for review.

Define Fallbacks

Next, define fallbacks so that you don't have to improvise under pressure. For example, is the default carrier/service unavailable or delayed? Define a short, approved alternate carrier/service list to use in these instances.

This keeps shipping decisions fast and consistent. It also makes the decision making process explainable both internally and to customers when questions come up.

4 - Batch Process and Automate What Repeats

One of the biggest shifts from early-stage merchants to high-performing merchants is moving from one-off actions to batch workflows.

High-volume merchants:

Process shipments in batches
Create and print labels in bulk
Automate repeatable steps (defaults, validations, routing) so humans handle exceptions

This does three things:

Reduces handling time per order
Creates consistency
Improves visibility into "what's done vs. what's blocked"

A Small but Real Concrete Example

Imagine generating a full batch of shipping labels only to discover several shipments failed due to bad addresses or missing fields that force identifying the failed shipments, correcting the issues, and reprocessing the labels.

Automating address checks and carrier/service defaults before label creation prevents a common, time consuming, and costly failure.

5 - Design an Exceptions Lane So Spikes Don't Equal Bottlenecks

Most workflows fail during spikes when exceptions cause bottlenecks. Promotions, holidays, and partner campaigns don't just increase volume they increase edge cases:

Address issues
Special packaging
Service-level constraints

Skip the bottlenecks by designing for reality:

Route edge cases into a separate queue so they are immediately visible and can be handled quickly
Keep a clean "happy path" for the majority of exceptions by referring to your decision anchor

This helps ensure that you stay in control under pressure.

6 - Close the Loop With Customer Communication

Shipping doesn't end when the label prints. This is where the post-purchase layer becomes customer-facing. Tracking and communication are how you maintain trust when things are moving normally and how you recover confidence when they aren't.

Here's a practical communications baseline:

Send tracking automatically when labels are created or at scan, depending on your operation.
Make status changes clear and understandable. Don't surface confusing carrier codes to your teams or customers.
Proactively communicate exceptions that affect delivery expectations, like when a package is delayed in transit.
Equip support with a single source of truth so they can answer "Where is my order?" inquiries quickly and accurately.

When communication is designed into the workflow, fewer customers need to ask, and when they do, your team has clarity and visibility to respond.

Common Pitfalls

Even strong merchants fall into these patterns, but they're easier to fix when you know which step is breaking. Here are a few common pitfalls to watch out for:

Data Import - "Just this once" spreadsheet cleanup: Temporary fixes become permanent workflows, and variability creeps back in.
Data Import - Tools that require perfect spreadsheets: If one small error forces a data import failure, work stalls and costly delays occur.
Validation - No validation before label creation: Issues surface late, turning small data problems into batch rework and customer-facing delays.
Defaults/Decision anchor - Manual shipping decisions: When every shipment is a judgment call, consistency drops and costs drift, especially during spikes.
Batch and automation - One-off actions instead of batch workflows: The team stays busy, but throughput doesn't scale and productivity drops.
Exceptions - No separate exceptions lane: A handful of edge cases blocks the entire line and destroys control.
Communication - Tracking exists, but communication isn't transparent: Customers get updates that don't answer real questions or get no communications at all, support volume rises, and customer trust erodes.

What to Measure So You Improve With Confidence

You don't need dozens of metrics. You need a few that reflect where trust and control are won or lost:

Labels per labor hour: Are you actually getting more efficient as volume increases?
Exception rate (manual intervention required) and shipping error rate: Where is friction turning into cost and customer-visible problems?
Order-to-label time: How quickly does work move through your system?
Cost per shipment (and cost variance vs baseline): Are your rules and decision anchor still aligned with margins?

These metrics create visibility into where the operating layer is breaking, and confidence that changes are working.

The Takeaway

Shipping success isn't just about moving faster. It's about removing friction and building an operating layer that holds up under pressure. Merchants that stay calm during spikes aren't working harder in the moment. They've already designed a successful workflow. They have:

Standardized data import for accuracy and clarity
Automated validation to surface issues early
Built a decision anchor for confident carrier flexibility
Batched and automated repeatable work
Separated exceptions so the line keeps moving
Designed tracking and communication to protect the customer experience

When shipping is built as a post-purchase operating layer, not a series of tasks, something shifts:

It becomes predictable. It becomes scalable. And it stops being the thing your ops team worries about.

And customers feel the difference: clearer tracking, fewer surprises, better communication, and a customer experience that earns trust after checkout, not just before it.