Shopify Enables Single-Checkout Ship & Pickup: What Developers and Merchants Must Do to Prevent Fulfillment Breaks

Table of Contents

1. Key Highlights
2. Introduction
3. How the checkout and fulfillment model changed
4. Why this matters: merchant experience and customer expectations
5. Technical implications for apps and integrations
6. Common failure scenarios and how to avoid them
7. Testing and developer checklist
8. Implementation patterns and code-level guidance
9. Operational best practices for merchants
10. Real-world scenarios and examples
11. Integration examples: carrier and marketplace considerations
12. Monitoring, analytics, and reporting impacts
13. Communication templates and merchant guidance
14. Migration considerations and timeline
15. Governance: roles and responsibilities
16. Frequently encountered edge cases and recommended handling
17. Monitoring and remediation steps after rollout
18. Final considerations for developers and merchants
19. FAQ

Key Highlights

• Shopify Plus and Enterprise merchants can now offer a single checkout where customers choose shipping or store pickup per item, producing one order with multiple fulfillment orders (SHIPPING and PICK_UP).
• No breaking API schema changes, but delivery and fulfillment data will appear in new combinations: multiple deliveryGroups on checkouts and fulfillment orders with a delivery_method field — developers must test and update app logic now.
• Follow a practical testing and rollout checklist to validate routing, shipping-label generation, inventory reservations, notifications, and merchant-facing workflows before the merchant rollout.

Introduction

Shopify has expanded checkout flexibility for merchants on Plus and Enterprise plans by allowing shoppers to mix shipping and in-store pickup for items within a single cart. The change produces one consolidated order that can split into multiple fulfillment orders, each with its own delivery method (SHIPPING or PICK_UP). That shift alters how checkout and fulfillment data appear through existing APIs. No new schema fields were added, but familiar fields will return in new combinations and patterns that many apps and integrations currently do not expect.

For developers and platform integrators, the challenge is immediate: apps that assume one delivery method per order will encounter errors, incorrect calculations, and misrouted fulfillment jobs if left untested. For merchants, the change improves the customer experience and operational flexibility but introduces new coordination demands for inventory, staffing, and communication. This article explains precisely what changed, why it matters, how to test and adapt apps, and which operational practices merchants should adopt to avoid disruptions.

How the checkout and fulfillment model changed

Previously, Shopify checkout flows and downstream fulfillment logic implicitly relied on a single delivery method per order: either the entire order shipped, or the whole order was set for local pickup. Merchants enabling both options required customers to place separate orders when a mix of delivery types was needed.

The new model lets customers decide delivery method at the item level during checkout. A single order can now produce more than one fulfillment order — for example, a fulfillment order for shipped items and another for pick-up items — each identified by a delivery_method field. On the checkout side, multiple deliveryGroups may appear, representing different sets of line items with distinct delivery options.

Key behavioral changes:

• Checkouts can include multiple deliveryGroups; each group represents a set of items and an associated fulfillment method or pickup location.
• Orders can contain multiple fulfillment orders with different delivery methods within the same order object.
• Fulfillment orders include a delivery_method field that explicitly indicates SHIPPING or PICK_UP for that fulfillment order.

No additional API fields have been introduced; instead, existing fields will carry combinations and patterns that were previously impossible. That difference is the primary source of potential integration failures.

Why this matters: merchant experience and customer expectations

The new capability reduces friction for customers who want different items delivered in different ways — think of a shopper who ships bulky furniture but picks up accessories in-store, or someone buying perishable groceries for same-day pickup alongside non-perishable items shipped later. Offering that flexibility increases conversion potential and can reduce abandoned carts caused by inconvenient delivery options.

Merchants gain several operational benefits:

• Reduced duplicate orders for mixed delivery preferences.
• Improved cross-sell and upsell opportunities during a single checkout session.
• Greater visibility into order composition for better operational planning.

However, these benefits come with operational complexity. Merchants must reconcile multiple fulfillment workflows for a single order, coordinate inventory allocation across locations, and ensure notifications and tracking reflect the multi-method nature of the order. Failure to update systems that handle shipping rates, label generation, or fulfillment routing will create customer confusion and operational bottlenecks.

Technical implications for apps and integrations

The primary technical implication is that apps cannot safely assume one delivery method per order. Many apps — including shipping label generators, order management systems (OMS), warehouse management systems (WMS), ERP connectors, and custom back-office integrations — currently process orders as a single fulfillment job. They must now treat each fulfillment_order independently.

Areas requiring attention:

• Fulfillment order handling
  • Treat each fulfillment_order separately. Read the fulfillment_order.delivery_method field and route tasks accordingly.
  • For SHIPPING fulfillment_orders, generate shipping labels and track shipments.
  • For PICK_UP fulfillment_orders, create pickup tasks, allocate inventory for in-store staging, and flag items for store staff.
• DeliveryGroups on checkout
  • Checkout objects can include multiple deliveryGroups. Ensure apps that read checkout-level delivery data iterate through deliveryGroups rather than relying on a single group or single delivery choice.
• Shipping rate calculations
  • Avoid applying per-order shipping rates indiscriminately. If shipping fees were previously calculated at the order level, re-evaluate whether shipping should be prorated, applied per shipping fulfillment_order, or recalculated at the line-item level based on which items are shipped.
• Label and carrier integration
  • Shipping label generation must be tied to the specific fulfillment_order(s) that require carrier services. Do not attempt to create a shipping label for an entire order when part of it is pickup-only.
  • Carrier-calculated rates and third-party carrier integrations need to accept per-fulfillment order inputs.
• Inventory and location allocation
  • When fulfillment_orders split across locations (for example pickup from Location A and shipping fulfilled from Location B), inventory reservations and transfers must reflect the demands of each fulfillment_order.
  • For merchants using multi-location inventory or distributed warehouses, ensure stock deduction and transfer flows do not double-count or leave items unreconciled.
• Notifications and tracking
  • Customer-facing notifications should be delivery-method aware. Send separate messages for shipped fulfillment_orders (with tracking numbers) and pickup fulfillment_orders (with pickup instructions and expected readiness time).
  • Order timelines in merchant dashboards should show fulfillment_order-level status updates.
• Refunds, cancellations, and returns
  • Handle these at the fulfillment_order level where appropriate. Refund logic that assumes a single fulfillment unit will miscompute amounts when only part of an order ships.
• Third-party fulfillment services and marketplaces
  • Fulfillment services that accept orders via APIs must be updated to accept and process multiple fulfillment_orders per parent order. Ensure the delivery_method is passed through and honored.

Common failure scenarios and how to avoid them

Anticipate specific failure modes that will surface if apps and merchant processes remain unchanged. Below are scenarios observed in similar transitions and practical mitigations.

Failure: Shipping labels created for entire order

• Issue: App creates a label for the full order even though some items are pickup-only, resulting in incorrect carrier billing and missing items in shipments.
• Fix: Generate labels only for fulfillment_orders with delivery_method == SHIPPING. Do not bundle pickup items into shipping labels.

Failure: Single shipping fee applied to mixed-method order

• Issue: A merchant or app applies a flat shipping charge to the order while items eligible for pickup are included, causing overcharging or undercharging.
• Fix: Recalculate shipping fees per shipping fulfillment_order. If shipping costs must be prorated across mix methods, define clear merchant-facing rules and implement prorating logic.

Failure: Inventory reserved at incorrect location

• Issue: App reserves inventory at a shipping origin when the pickup fulfillment_order should reserve items at a store location.
• Fix: Use fulfillment_order.location_id and checkout deliveryGroups to allocate inventory at the correct location for PICK_UP fulfillment_orders.

Failure: Pickup orders not staged or noticed by store staff

• Issue: Pickup fulfillment_orders are created but merchant staff do not receive a clear pickup task or the order is not flagged in POS.
• Fix: Integrate fulfillment_orders with POS and store operations. Create a pickup workflow that triggers notifications, generates pick lists, and ties pickup readiness to safe-guarded hold periods.

Failure: Refunds and returns misapplied

• Issue: A return is processed against the whole order or the wrong fulfillment_order, causing incorrect merchant reimbursements.
• Fix: Associate returns and refunds to the specific fulfillment_order and its items. Ensure applications can recompose order-level totals after fulfillment-order-level adjustments.

Failure: Customer receives mixed or confusing notifications

• Issue: Customers get a single tracking email for an order when only part of the order ships, or pickup instructions are not clear.
• Fix: Implement separate, clearly labeled communications per fulfillment_order. Include pickup codes, store location, and pickup windows for PICK_UP. Include carrier and tracking details for SHIPPING.

Testing and developer checklist

Shopify provides a testing guide and a feature preview to simulate the new behavior. Use the steps below to build confidence before the change rolls out to production merchants.

1. Enable feature preview
   • Activate the Ship & Pickup feature in your developer dashboard to access the preview environment and simulated checkouts.
2. Review the testing guide
   • Walk through the provided PDF testing guide for scenarios, sample payloads, and recommended validation points.
3. Audit assumptions in your app logic
   • Search code for assumptions like “one delivery method per order,” “single fulfillment object per order,” or single group shipping calculations.
   • Identify modules that touch checkout.deliveryGroups, order.fulfillment_orders, shipping rate computations, label creation, and inventory allocation.
4. Update fulfillment_order handling
   • Modify processing pipelines to iterate over order.fulfillment_orders.
   • Read fulfillment_order.delivery_method and fulfillment_order.location_id; route shipping to carrier integrations and pickup to store workflows.
5. Test end-to-end scenarios
   • Place test orders in the preview that combine shipped and pickup items.
   • Validate that:
     • fulfillment_orders are created correctly with delivery_method values.
     • Shipping labels are generated only for SHIPPING fulfillment_orders.
     • PICK_UP fulfillment_orders create pickup tasks and allocate store inventory.
     • Customer notifications reflect the correct fulfillment methods.
6. Validate edge cases
   • Orders where all items are PICK_UP or all SHIPPING (should behave as before).
   • Items split across multiple pickup locations and shipped items from other locations.
   • Orders with line-item discounts, free shipping thresholds, or shipping promotions.
   • Partial refunds and returns applied to selected fulfillment_orders.
7. Observe merchant-facing changes
   • Confirm that merchant dashboards show fulfillment_order-level status and that staff can manage pickup tasks.
   • Prepare documentation and UI changes in your app to reflect multi-fulfillment-order states.
8. Communicate changes to merchants
   • Provide early warnings to merchants using your app. Explain how their workflows will change and offer migration instructions.
9. Monitor after rollout
   • After merchants enable the change, monitor logs for errors tied to fulfillment order processing, unexpected shipping charges, or failed label creations.
   • Track support tickets for pickup-related operational issues.
10. Fallback plans and rollback

• Create scripts or tools to reprocess orders that were misrouted during testing.
• Keep a safe rollback plan for your app release in case unexpected edge cases occur in production.

Implementation patterns and code-level guidance

Below are practical implementation patterns to update apps. These patterns are language-agnostic; adapt them to your stack.

Pattern: Fulfillment-order-first processing

• Do not treat the parent order as the single fulfillment unit. Instead, iterate through order.fulfillment_orders and process each according to its delivery_method.

Pseudocode example:

• Note: The following is conceptual and must be adapted to your API client and language.

1. Fetch the order and its fulfillment_orders.
2. For each fulfillment_order:
   • Read delivery_method and location_id.
   • If delivery_method == "SHIPPING":
     • Determine shipping address and carrier options.
     • Generate shipping label and update fulfillment_order with tracking info.
   • If delivery_method == "PICK_UP":
     • Allocate inventory at location_id.
     • Generate pickup instructions and pickup code.
     • Notify store staff and the customer.

Edge handling:

• If a fulfillment_order cannot be fulfilled by the assigned location due to stockouts, trigger location transfers or alert merchant.
• If the shipping rate for a shipping fulfillment_order changes after label creation, reconcile charges and notify the merchant.

Pattern: Shipping rate recomputation

• Compute shipping rates per shipping fulfillment_order rather than at the parent order level.
• For merchants who prefer a single shipping fee per order, provide a configurable option that defines how shipping should be aggregated or split.

Pattern: Notification separation

• Send messages keyed to fulfillment_order IDs.
• Use clear subject lines: “Your pickup order is ready” versus “Your shipment is on the way.”

Pattern: UI changes for merchant apps

• Surface fulfillment_orders separately in the order view.
• Provide action buttons at the fulfillment_order level (e.g., “Create shipping label”, “Mark as ready for pickup”).

Operational best practices for merchants

Merchants must align store operations and logistics with the new mixed-delivery model. Practical steps:

1. Update POS and in-store pick workflows
   • Ensure POS or store apps display pickup tasks and allow staff to mark items as picked and ready.
   • Create visible pickup staging areas and scanning procedures to prevent misplaced items.
2. Train store and warehouse teams
   • Deliver training on recognizing multi-fulfillment orders and the need to update packing slips or in-store pickup signage.
   • Establish a documentary trail to link pickup transactions to customer IDs or pickup codes.
3. Set clear pickup instructions and windows
   • Provide customers with clear pickup expectations, including where to go in-store, required identification or codes, and expected readiness times.
   • Consider pickup holds and expiration windows to avoid indefinite holds on items.
4. Inventory management and transfers
   • Keep inventory balances in sync across locations. Automate transfer requests if stock resides at a different location than the pickup store.
   • Implement minimum stock thresholds to prevent accepting pickup orders for out-of-stock items.
5. Shipping rules and promotions
   • Revisit free-shipping thresholds and promotions that previously applied at the order level. Decide whether promotions should consider only shipping items, pickup items, or both.
   • Communicate any policy changes to customers clearly.
6. Staff scheduling and forecasting
   • Anticipate variations in workload from pickup orders (peaks at midday or after work hours) and schedule staff accordingly.
   • Use reporting to forecast pickup demand and adjust staffing.
7. Returns and exchanges policy clarity
   • Clarify whether returns for pickup items must be returned in-store or can be shipped.
   • Ensure return-processing workflows can handle mixed-origin returns.
8. Fraud and identity verification
   • Implement pickup verification measures (ID or pickup code) to reduce fraudulent pickup claims.
   • Consider adding optional photos of ID or two-factor verification for high-value pickups.

Real-world scenarios and examples

Example 1 — Apparel retailer with omnichannel inventory

• Situation: A customer orders a jacket (shipped) and matching sunglasses (picked up at a local store).
• Before: The customer would place two orders or the merchant would force one fulfillment method, creating friction.
• After: Single checkout creates a shipping fulfillment_order for the jacket and a pickup fulfillment_order for the sunglasses. The retailer's OMS generates a shipping label for the jacket and a pickup ticket for the store staff for the sunglasses. The customer gets two distinct notifications: tracking for the jacket and pickup instructions for the sunglasses.

Example 2 — Grocery chain with frozen items

• Situation: A customer orders shelf-stable pantry items (shipped) and frozen goods (pickup to preserve cold chain).
• Before: Merchant forced a single delivery method or the customer had to place separate orders.
• After: Checkout splits items into a shipping fulfillment_order and a pickup fulfillment_order. The frozen items are flagged for immediate pickup and reserved until collection. Shipping fulfillment_orders use standard carrier options.

Example 3 — Furniture plus accessories

• Situation: Large furniture items require special freight shipping; small decor items can be picked up in-store.
• Implementation: Merchants configure freight carrier integrations to process the shipping fulfillment_order. Pickup fulfillment_order triggers a warehouse pull-and-stage process for accessories. Both workflows are visible on the same parent order, simplifying customer service.

These scenarios show tangible benefits for conversion and operations, but only when the supporting systems and staff are aligned.

Integration examples: carrier and marketplace considerations

Carrier integrations

• Carrier integrations must support fulfillment-order-specific label creation. Ensure carriers accept partial shipment requests that reference a parent order and the particular fulfillment_order.
• For carrier-calculated rates at checkout, shipping rate lookups should be scoped to the shipping deliveryGroup to avoid inflating costs for pickup items.

Marketplace and third-party fulfillment

• If part of an order is fulfilled by a third-party fulfillment provider (3PL), ensure that the integration can accept a fulfillment_order with delivery_method == SHIPPING while pickup fulfillment_orders remain under the merchant’s control.
• Coordinate the transfer of fulfillment_order-level metadata so the 3PL knows what items and quantities to ship.

ERP and warehouse systems

• ERP systems commonly consume orders as a single record. Update ETL and integration jobs to decompose an order into multiple fulfillment jobs with tags for delivery_method and location_id.
• Warehouse management workflows should be able to queue and route fulfillment_orders to appropriate pick waves and packing stations.

Monitoring, analytics, and reporting impacts

Reporting needs to reflect the multi-fulfillment nature of orders.

Sales and fulfillment metrics

• Track shipment volumes per fulfillment_order and pickup volumes per store to understand how delivery methods shift over time.
• Monitor average time-to-ready for pickup fulfillment_orders and compare against shipping fulfillment_order lead times.

Financial reporting

• Break down revenue and shipping costs by fulfillment_order to avoid misattributing shipping expenses.
• When promotions apply differently to pickup vs. shipped items, ensure your financial reports align with the chosen policy.

Customer service metrics

• Monitor customer inquiries by fulfillment method. Expect different kinds of tickets: pickup readiness or missing pickup items vs. tracking and carrier issues for shipped items.

Operational KPIs

• Track fulfillment_order cancellation and refund rates separately. High pickup cancellation rates might indicate problems in store readiness or customer communication.

Set up alerts

• Create automated alerts for anomalies such as back-to-back failed label generations, large numbers of pickup fulfillment_orders with unallocated inventory, or frequent split-fulfillment edits.

Communication templates and merchant guidance

Merchants should receive clear, practical guidance to minimize disruption. Provide simple templates that explain changes and required actions.

Merchant communication sample (concise)

• Subject: Action required — Support for mixing shipping and pickup in a single checkout
• Body: We’ve added support for mixed shipping and pickup per order. Please review your app settings and processes. Key changes: multiple fulfillment orders per order, per-fulfillment shipping label creation, and separate pickup tasks. Test now in feature preview and update staff procedures.

Customer-facing pickup instruction template

• Subject: Your pickup is ready at [Store Name]
• Body: Your order [Order Number] is ready for pickup at [Location]. Please bring [Pickup Code] and photo ID. Pickup hours: [Hours]. If you need help, reply to this message or call [Phone].

Shipping notification template

• Subject: Your shipment is on the way — Order [Order Number]
• Body: Part of your order has shipped. Carrier: [Carrier Name]. Tracking number: [Tracking Number]. Items shipped: [List]. Items remaining for pickup: [List]. Expected delivery: [Date].

Operational checklist for store staff

• Verify pickup code and ID.
• Scan items into the POS as “picked” and “ready.”
• Update the fulfillment_order status in the merchant dashboard.
• Capture customer signature or electronic confirmation at pickup.

Migration considerations and timeline

Shopify’s preview environment lets developers test changes before the merchant rollout. Plan migration in phases:

1. Code audit and remediation (1–3 weeks)
   • Identify and fix code paths that assume single fulfillment per order.
   • Update shipping, labelling, and inventory logic.
2. Testing and QA (2–4 weeks)
   • Execute the testing guide scenarios.
   • Run stress tests that simulate high concurrency and multiple pickup locations.
3. Merchant documentation and beta rollout (1–2 weeks)
   • Provide merchant-facing documentation and optional training sessions.
   • Offer a controlled beta program for selected merchants to provide feedback.
4. Production rollout and monitoring (ongoing)
   • Monitor logs and merchant support tickets closely.
   • Be ready to issue quick fixes for edge cases.

Adjust timelines depending on the size of the app or integration and the complexity of merchant configurations.

Governance: roles and responsibilities

Define ownership so that technical and operational teams coordinate effectively.

For developers and engineering teams

• Update code, test, and release changes.
• Monitor integrations and error rates post-deployment.
• Provide technical support for merchants with complex setups (multi-location, external ERPs).

For product and merchant success teams

• Prepare knowledge base articles and merchant-facing FAQs.
• Coordinate merchant communications and training sessions.
• Prioritize merchant requests that surface unique edge cases.

For merchant operations and store managers

• Update in-store processes and staff training.
• Adjust inventory thresholds and transfer rules.
• Provide feedback to app developers for workflow refinements.

Frequently encountered edge cases and recommended handling

Edge case: Partial pickup and split shipments for a single line item (bundles or multi-quantity)

• Handling: If a line item contains multiple quantities and the customer selects different delivery methods for individual units, ensure fulfillment_orders reflect the split appropriately. Your app must accept fractional splits per line item and generate separate fulfillment instructions.

Edge case: Items fulfilled by third-party logistics and pickup at store simultaneously

• Handling: Tag fulfillment_orders with provider IDs. Pass the shipping fulfillment_order to the 3PL and handle pickup fulfillment_order in-store. Ensure coordination for returns.

Edge case: Free shipping thresholds affected by pickup items

• Handling: Decide whether the free-shipping qualification should be based on the total order value or only shipping items. Implement that rule consistently and show it clearly at checkout to avoid customer confusion.

Edge case: Customer edits the order after initial fulfillment order creation

• Handling: Support re-evaluating and re-creating fulfillment_orders. Ensure label voiding and re-issuance flows are robust. For pickup edits, update pickup instructions and notify store staff immediately.

Edge case: Multi-location pickup

• Handling: If pickup items are available at multiple stores, allow customers to choose pickup location per item or ensure the checkout directs items to a single pickup location per deliveryGroup. Validate inventory at the selected location before completion.

Edge case: Local delivery vs. pickup

• Handling: Distinguish between local delivery and store pickup. Define local delivery as a shipping method with a local carrier or courier and map it to SHIPPING delivery_method if labels and carrier tracking are required.

Monitoring and remediation steps after rollout

Immediate checks

• Monitor errors referencing fulfillment_order processing and delivery_method handling.
• Track shipping label generation success rate.
• Watch for increases in customer support tickets labeled “pickup” or “missing items.”

Remediation procedures

• If misrouted shipments appear, pause auto-labeling for affected merchants and reprocess fulfillment_orders manually.
• Provide merchant-facing troubleshooting steps for failed pickup allocations or missing items.
• Offer temporary operational workarounds: instruct store staff to confirm fulfillment_orders via the merchant dashboard until full automation is restored.

Long-term monitoring

• Maintain dashboards that report fulfillment_order volumes, split-order percentages, and per-fulfillment average completion times.
• Use A/B testing or phased deployment to measure the impact on conversion and support load.

Final considerations for developers and merchants

This update brings a meaningful improvement to customer flexibility and merchant efficiency by allowing mixed delivery methods in a single checkout. The primary risk is that legacy assumptions in app logic or merchant workflows will lead to misrouted shipments, incorrect fees, or unfulfilled pickups. The technical change is modest — no new API fields — but the combinations in which existing fields appear are new and significant.

Developers must identify code that treats the parent order as a single fulfillment unit and shift to a model that processes fulfillment_orders individually. Merchants need to update store operations, staff training, inventory practices, and communications to customers. Testing in Shopify’s feature preview is essential; follow the testing guide closely and validate the end-to-end user journeys that matter most to your merchants.

FAQ

Q: Which merchants can use the new single-checkout ship-and-pickup capability? A: Shopify Plus and Enterprise merchants are eligible to enable mixed shipping and pickup within a single checkout.

Q: Do I need to change API calls because of this update? A: There are no breaking schema changes, but existing API fields (e.g., checkout.deliveryGroups and order.fulfillment_orders) will present new combinations. Update your processing logic to iterate through multiple deliveryGroups and fulfillment_orders and to read the fulfillment_order.delivery_method field.

Q: Where should apps look to determine whether an item is for shipping or pickup? A: Inspect each fulfillment_order’s delivery_method and, on the checkout object, review deliveryGroups. Use fulfillment_order.location_id to determine the location responsible for pickup or shipment.

Q: Will shipping rates at checkout change automatically for mixed orders? A: Shipping rates may require recalculation. If your logic assumed a single shipping charge per order, update it to compute per shipping fulfillment_order or implement a merchant-configurable rule for prorating or aggregating shipping fees.

Q: How should customer notifications be handled for mixed delivery orders? A: Send separate, clearly labeled notifications per fulfillment_order: shipping notifications with tracking details and pickup notifications with pickup codes, location, and readiness windows.

Q: What are the primary test scenarios developers should run? A: Test orders that mix shipping and pickup items, orders where all items are pickup, orders where all items ship, split-line-item scenarios, orders with promotions or discounts affecting shipping, multi-location pickup, and refund/return flows tied to specific fulfillment_orders.

Q: Will existing merchant dashboards show the new fulfillment order split? A: Shopify will surface fulfillment_orders in order details. Apps and merchant-facing tools should display fulfillment_order-level details and provide controls to manage pickup and shipping tasks independently.

Q: What happens if I don’t update my app? A: Apps that assume a single delivery method per order risk producing checkout errors, incorrect shipping calculations, failed label generation, inventory misallocations, and fulfillment routing issues. These problems will degrade the merchant’s checkout and fulfillment experience.

Q: Where can developers find more information and support? A: Use the Shopify developer dashboard to enable the feature preview, consult the Ship and pickup testing guide, and follow the Shopify developer community post linked in the preview materials for ongoing updates and peer support.