Home Blog Article

How to Actually Track 3PL Performance (Since Shopify Can't)

Published on October 2025 • 8 min read

Shopify knows exactly when your 3PL handed packages to the carrier. It tracks delivery confirmations. It even monitors in-transit delays.

The data exists. You just can’t see it without building something custom.

Here’s what Shopify actually tracks, what’s still missing, and why “just check Shopify” doesn’t work for monitoring 3PL performance.

What Shopify Actually Tracks Now

As of September 2025, Shopify added a new CARRIER_PICKED_UP status to fulfillment events. Combined with existing tracking data, here’s what Shopify knows:

Fulfillment Events Shopify Tracks:

  • LABEL_PURCHASED: Your 3PL bought a shipping label
  • LABEL_PRINTED: Label was printed (not the same as shipped)
  • CONFIRMED: 3PL marked the order fulfilled in their system
  • CARRIER_PICKED_UP: Carrier scanned the package at pickup (the key timestamp)
  • IN_TRANSIT: Package is moving through carrier network
  • OUT_FOR_DELIVERY: Package is on delivery vehicle
  • DELIVERED: Customer received the package
  • ATTEMPTED_DELIVERY: Delivery was attempted but failed
  • DELAYED: Carrier flagged a delay

See full list of FulfillmentEventStatus values

Timestamps Available:

  • createdAt: When the fulfillment record was created in Shopify
  • happenedAt: When the event actually occurred (this is the one that matters)
  • estimatedDeliveryAt: Carrier’s delivery estimate

The data is rich. CARRIER_PICKED_UP is the actual handoff moment. The difference between order creation and that pickup timestamp? That’s your 3PL’s fulfillment speed.

The Two Problems: Missing Data and No Way to Use It

Here’s where it breaks down. Shopify built the plumbing, but the pipes are often empty.

Problem 1: Most 3PLs Don’t Send Complete Data

Even though Shopify supports all these events, your 3PL might only send a few:

  • Basic integrations: Many 3PLs only mark orders “fulfilled” when they print a label. No CARRIER_PICKED_UP event. No IN_TRANSIT updates. Just “fulfilled” and maybe a tracking number.
  • Carrier data gaps: CARRIER_PICKED_UP depends on carriers reporting pickup scans. Regional carriers or international shipping often lack this data entirely.
  • Legacy systems: Older WMS platforms weren’t built to send granular fulfillment events. They meet minimum requirements and stop there.

So those 11 event types? You might only see 2-3 per order. The rest just never get populated.

Problem 2: Even When Data Exists, You Can’t Use It

For the events that do get sent, Shopify stores them but doesn’t turn them into actionable metrics.

What you can’t do in Shopify:

  1. Calculate handoff time - Shopify won’t show you “order received → carrier pickup” as a number
  2. Track performance over time - No charts showing if your 3PL is getting faster or slower
  3. Compare locations - If you use multiple 3PLs, you can’t compare their speed
  4. Set up alerts - No notifications when handoff times exceed your SLA
  5. Detect mispicks - Carrier weight data exists but isn’t compared to expected weights
  6. Monitor inventory accuracy - Can’t track sync issues or discrepancies over time

You can see individual fulfillment events by digging into the Order page, clicking through to fulfillment details, and scrolling through the timeline. But that’s it. One order at a time. No aggregation. No trends. No alerts.

The Metrics That Matter (But Shopify Doesn’t Show)

Here’s what you actually need to monitor 3PL performance:

1. Handoff Time (Order Created → Carrier Pickup)

This is your 3PL’s core metric. How long from order placement to carrier scan?

The data exists:

  • Order createdAt timestamp
  • FulfillmentEvent with CARRIER_PICKED_UP status and its happenedAt timestamp

What Shopify doesn’t do:

  • Calculate the delta between these timestamps
  • Show you P50, P95 percentiles across orders
  • Alert you when times exceed thresholds
  • Break it down by product, location, or time of day

2. Label Generation Lag (Fulfilled → Carrier Pickup)

When your 3PL marks an order fulfilled vs. when the carrier actually scans it. This catches “label and wait” behavior where packages sit after being “shipped.”

The data exists:

  • Fulfillment createdAt or CONFIRMED event
  • CARRIER_PICKED_UP event

What Shopify doesn’t do:

  • Flag excessive gaps (more than 4 hours suggests problems)
  • Track this metric over time
  • Compare across different 3PLs or locations

3. Delivery Promise Accuracy

Did the package arrive when the carrier said it would?

The data exists:

  • estimatedDeliveryAt from carrier
  • DELIVERED event with actual delivery timestamp

What Shopify doesn’t do:

  • Calculate on-time delivery percentage
  • Track early vs late deliveries
  • Factor this into 3PL performance scoring

4. In-Transit Issues

Delays, attempted deliveries, or exceptions during shipping.

The data exists:

  • DELAYED events
  • ATTEMPTED_DELIVERY events

What Shopify doesn’t do:

  • Aggregate these by 3PL to see if one provider has more carrier issues
  • Alert you when exception rates spike
  • Track root causes (wrong address, damaged package, etc.)

Why This Matters: The Label Generation Problem

Here’s a real example of why you need more than Shopify’s UI:

Your 3PL reports 95% same-day fulfillment. Looks great in their dashboard. But when you dig into the actual timestamps:

  • 2:00 PM: Order placed
  • 3:30 PM: 3PL marks order “fulfilled” (generates label)
  • 11:45 AM next day: Carrier pickup scan (CARRIER_PICKED_UP event)

Your 3PL counts this as “same day” because they created the label before midnight. But the package didn’t actually move for 21 hours.

Shopify has both timestamps. But you’d have to manually check each order to catch this pattern.

What You’d Need to Build (Or Buy)

To actually use Shopify’s fulfillment data for 3PL monitoring, you need:

1. Webhook Listeners

Subscribe to fulfillments/create and fulfillment_events/create webhooks to capture events as they happen.

2. Data Warehouse

Store events over time so you can calculate trends and percentiles.

3. Metric Calculations

Write code to:

  • Calculate handoff time from order to carrier pickup
  • Compute P50/P95 percentiles across time windows
  • Compare performance across locations
  • Detect anomalies and outliers

4. Alerting System

Notify you when:

  • Handoff times exceed thresholds
  • Performance degrades week-over-week
  • Specific locations underperform
  • Exception rates spike

5. Reporting UI

Dashboards to visualize:

  • Performance trends over time
  • Location comparisons
  • Order-level drill-downs
  • SLA compliance rates

This isn’t trivial. It’s weeks of development work, ongoing maintenance, and infrastructure costs.

The Workarounds (What Merchants Actually Do)

Without custom tooling, here’s how merchants try to monitor 3PL performance:

Manual Order Sampling

Pick 20-30 orders per week. Manually check timestamps. Calculate handoff time in a spreadsheet. This works for spot checks but misses systematic issues.

3PL-Provided Reports

Ask your 3PL for weekly performance reports. Hope they’re measuring the right things and being honest. Cross-reference against a few Shopify orders to verify.

Carrier Performance Only

Track delivery times from carrier data. This tells you about UPS/FedEx but says nothing about your 3PL’s handoff speed.

React to Customer Complaints

Wait for customers to complain about slow shipping. Investigate after the fact. Not ideal.

None of these are systematic. None catch problems before customers feel them.

What’s Actually Missing from Shopify

Even with all the fulfillment events, some data still doesn’t exist:

Not tracked by Shopify:

  • Inventory cycle count accuracy - You can see inventory levels but not how often adjustments happen
  • Mispick detection - Carrier weight data isn’t exposed or compared to expected weights
  • Pick/pack/ship breakdowns - No timestamps for individual warehouse steps
  • Cost per order - Fulfillment fees aren’t tracked in Shopify
  • Return processing speed - Returns are tracked but processing time isn’t calculated

These would require your 3PL to send additional data or integrate more deeply.

The Bottom Line

Shopify has made huge progress with fulfillment tracking. The CARRIER_PICKED_UP event is exactly what’s needed to measure 3PL performance accurately.

But two problems remain:

  1. Most 3PLs don’t send complete event data through Shopify’s APIs
  2. Even when data exists, Shopify doesn’t calculate or surface the metrics you need

If you’re serious about monitoring 3PL performance, you need to either:

  1. Build custom tools to process Shopify’s webhook data and fill gaps with direct integrations
  2. Use an app that does this for you

The infrastructure exists. The data is often incomplete. And the metrics aren’t calculated anywhere in Shopify’s UI.

3PL Pulse integrates directly with major 3PLs like ShipBob and Amazon FBA to get complete data, not just what flows through Shopify. We calculate handoff time, track performance trends, and alert you when 3PLs miss SLAs. For 3PLs with deep integrations, we get data that Shopify never sees. For everyone else, we extract every bit of signal from Shopify’s events and fill in the gaps.

But first, at least now you know what data Shopify actually has and why you can’t just “check the admin.”

Additional Resources

Ready to optimize your fulfillment operations?

Get early access to our platform and start tracking these metrics across your 3PL network.