Shopify Plus Customisation: Scripts, Flows, and Extensions

Shopify Plus is not just a more expensive version of Shopify. It is a fundamentally different platform that unlocks customisation capabilities unavailable at any other tier. Scripts that modify checkout behaviour. Flow automations that eliminate manual operations. Checkout Extensions that let you redesign the purchase experience. Functions that extend the platform's core logic.

The challenge for most brands is not knowing these tools exist — it is knowing when to use each one, how they interact, and where the boundaries are. This guide provides that practical understanding. It is written for ecommerce directors, marketing managers, and developers working with Shopify Plus, covering both strategic considerations and technical implementation.

What Shopify Plus gives you that standard plans do not

Before diving into individual tools, it is worth understanding the full scope of Shopify Plus exclusives that relate to customisation. Beyond the tools we will cover in detail, Plus provides access to the Multipass API for SSO integration, the Launchpad tool for scheduling flash sales and product launches, additional staff accounts, and dedicated support through a Merchant Success Manager.

The customisation tools specifically are:

• Shopify Scripts / Functions: Server-side logic that modifies pricing, shipping, and payment behaviour at checkout
• Shopify Flow: Visual automation builder for backend workflows (now also available on Advanced plans, but with fewer connectors)
• Checkout Extensions: UI components that extend the checkout experience
• B2B channel: A dedicated wholesale channel with company accounts and custom pricing
• Additional API capacity: Higher rate limits for custom integrations and headless implementations

Understanding which tool solves which problem is the key to effective Shopify Plus customisation. Using the wrong tool for a given requirement creates technical debt, performance issues, and maintenance overhead. For context on when Plus makes sense for your brand, see our guide to enterprise ecommerce on Shopify for growing brands.

Shopify Scripts and Shopify Functions

Shopify Scripts were the original Plus-exclusive customisation tool. They are Ruby-based snippets that run server-side during the checkout process, modifying line item prices, shipping rates, and payment method availability in real time. Scripts are powerful, but Shopify is actively transitioning them to Shopify Functions — a more modern, performant, and extensible system.

What Scripts can do

Scripts operate in three categories:

• Line item scripts: Modify cart contents and pricing. Use cases include automatic percentage or fixed-amount discounts, buy-one-get-one offers, tiered pricing based on quantity, and removing products from the cart based on conditions.
• Shipping scripts: Modify shipping rates at checkout. Use cases include free shipping for orders above a threshold, hiding or renaming shipping options, and adding surcharges for specific delivery regions.
• Payment scripts: Modify payment method availability. Use cases include hiding payment methods for specific customer groups (e.g., removing cash on delivery for first-time customers), reordering payment options, or enforcing specific payment methods for B2B orders.

The transition to Shopify Functions

Shopify Functions represent the evolution of Scripts. They run as WebAssembly modules, which means they execute faster and can be written in any language that compiles to Wasm (typically Rust or JavaScript). Functions are deployed as part of a Shopify app, which makes them easier to version, test, and maintain than inline Script code.

The key difference is scope. Functions currently support discount logic, payment customisation, delivery customisation, and cart and checkout validation. Shopify is expanding the Function API surface over time, and the long-term direction is for Functions to replace Scripts entirely.

For new Shopify Plus implementations, we recommend building with Functions from the start. For existing stores with Scripts, there is no immediate urgency to migrate — Scripts continue to work — but planning the transition to Functions is prudent as Shopify's roadmap moves in that direction.

Practical Script/Function examples

// Example: Tiered discount logic (conceptual)
// Buy 2 items: 10% off
// Buy 3 items: 15% off
// Buy 5+ items: 20% off

function applyTieredDiscount(cart) {
  const itemCount = cart.lines.reduce(
    (sum, line) => sum + line.quantity, 0
  );

  if (itemCount >= 5) return 0.20;
  if (itemCount >= 3) return 0.15;
  if (itemCount >= 2) return 0.10;
  return 0;
}

This kind of tiered pricing logic is one of the most common Script/Function use cases. Without it, you would need a discount app (adding JavaScript and API calls) or manual discount codes (which customers might not apply). Scripts and Functions handle it server-side with zero impact on storefront performance.

Shopify Flow: automating operations

Shopify Flow is a visual workflow automation tool that eliminates manual, repetitive operational tasks. It works on a trigger-condition-action model: when something happens (trigger), check if certain criteria are met (condition), then do something (action).

High-impact Flow automations

The most valuable Flow automations for Shopify Plus brands typically fall into these categories:

Inventory management

• When inventory drops below a threshold, send a Slack notification and email to the purchasing team
• When inventory reaches zero, hide the product from collections and unpublish from sales channels
• When new inventory is received, republish the product and tag it as "back in stock"

Order management

• When an order is placed above a certain value, tag it as VIP and notify the customer service team
• When an order has a high fraud risk score, hold the order and flag it for manual review
• When an order ships, add the customer to a post-purchase email segment in Klaviyo

Customer management

• When a customer places their third order, tag them as "loyal" and add them to a VIP segment
• When a customer's lifetime spend exceeds a threshold, upgrade their customer tier
• When a customer creates an account, check if they are a B2B customer and assign appropriate tags

Flow connectors and integrations

Flow becomes significantly more powerful through its connector ecosystem. Integrations with Klaviyo, Slack, Google Sheets, Asana, and other tools let you build automations that span your entire tech stack. For example: when a customer leaves a five-star review (trigger from your review app), add them to a brand ambassador segment in Klaviyo (action through Klaviyo connector), and post a notification in your marketing Slack channel (action through Slack connector).

The best Shopify Flow automations are the ones you set up once and never think about again. They eliminate the human error and time waste of manual processes, and they scale infinitely as your order volume grows.

Checkout Extensions and UI customisation

The checkout is where revenue is won or lost. Checkout customisation on Shopify Plus through Checkout Extensions lets you modify the checkout experience without touching the core checkout code, which means your customisations are upgrade-safe and secure.

Types of Checkout Extensions

Checkout UI Extensions are React-based components that render within the checkout flow. They run in a sandboxed environment, so they cannot access sensitive payment data but can interact with the checkout state through a controlled API. The extension points include:

• Before the first section: Add announcements, trust signals, or estimated delivery information at the top of checkout
• Between sections: Insert upsell offers, gift message fields, or loyalty point displays between the standard checkout sections
• After the last section: Add order notes, marketing opt-ins, or referral programme elements
• Order summary: Modify the order summary sidebar with additional information, promotional messages, or dynamic content

Revenue-driving checkout customisations

The checkout customisations that generate the most measurable revenue impact are:

Checkout upsells. Presenting a complementary product offer within the checkout flow can increase AOV without requiring the customer to leave checkout. The key is relevance: the upsell should be based on what is already in the cart, priced as an impulse purchase, and presented as a one-click add.

Delivery date selection. Letting customers choose their preferred delivery date reduces enquiries and increases satisfaction. For perishable products, subscription boxes, and gift purchases, this is particularly valuable.

Trust elements. Displaying security badges, return policy summaries, and customer review counts within the checkout reinforces confidence at the critical moment of payment. These elements are particularly effective for first-time customers and higher-value orders.

Custom theme development on Plus

Shopify Plus themes have access to the same Online Store 2.0 architecture as standard Shopify, but Plus merchants benefit from additional capabilities: access to the checkout Liquid files (for legacy checkout customisation), higher theme asset limits, and the ability to use theme-level JavaScript and CSS without the performance constraints of managed themes.

For brands on Shopify Plus, custom theme development is typically the right approach. Pre-built themes are designed for broad compatibility, which means they carry code and functionality you do not need. A custom theme built specifically for your brand eliminates unnecessary code, optimises for your specific product catalogue and content structure, and implements design decisions that support your conversion strategy.

Theme architecture considerations for Plus

When building a custom theme for Shopify Plus, consider the following architectural decisions:

• Section-everywhere architecture. Online Store 2.0 supports sections on every page, not just the homepage. Build reusable section components that your marketing team can arrange and configure without developer involvement.
• Metafield-driven content. Use metafields for structured product data (materials, dimensions, care instructions) and metaobjects for reusable content blocks (FAQs, size guides, material specifications). This keeps content manageable and consistent across the site.
• Performance-first CSS and JavaScript. Load critical CSS inline, defer non-critical styles, and lazy-load JavaScript modules. On Shopify Plus, you have the flexibility to implement aggressive performance optimisation strategies that pre-built themes cannot support.
• Market-aware templates. If you are selling internationally, build templates that adapt based on the customer's market: different hero imagery, market-specific trust badges, and localised content blocks.

B2B channel customisation

Shopify Plus's native B2B channel is one of the most significant Plus exclusives for brands that sell both wholesale and direct-to-consumer. The B2B channel provides company accounts, custom price lists, payment terms, and a separate buying experience — all from the same Shopify admin.

Customising the B2B experience

The B2B channel supports customisation through:

• Custom price lists: Set different prices for different customer companies, product categories, or order quantities. Price lists can be percentage-based (20% off retail) or fixed prices per product.
• Payment terms: Offer net 30, net 60, or custom payment terms to wholesale customers. Invoicing and payment tracking are handled through the Shopify admin.
• Minimum order quantities: Set minimum order quantities at the product or order level to ensure wholesale orders meet your fulfilment thresholds.
• Draft orders and quick ordering: B2B customers can reorder from previous orders, use quick-order forms, and your team can create draft orders for phone or email orders.

Practical customisation examples

Here are real-world customisation scenarios we have implemented for Shopify Plus brands, showing how the different tools work together:

Scenario: tiered loyalty programme

Flow monitors customer lifetime spend and automatically updates customer tags when spend thresholds are crossed (Bronze at £200, Silver at £500, Gold at £1,000). Functions read these tags at checkout and apply tier-specific discounts (5%, 10%, 15%). Checkout Extensions display the customer's current tier and how much more they need to spend to reach the next level.

Scenario: automated fraud prevention

Flow evaluates orders against multiple criteria: first-time customer with a high-value order, billing and shipping address mismatch, and high-risk fraud analysis score. Orders meeting multiple criteria are automatically held, tagged for review, and a Slack notification is sent to the operations team. This reduces chargebacks without blocking legitimate orders.

Scenario: dynamic shipping logic

Functions modify shipping rates based on cart contents: oversized items get specific carrier options, orders above a weight threshold are automatically routed to a freight carrier, and free shipping is applied only to standard-sized items. Checkout Extensions display estimated delivery dates based on the selected shipping method and the customer's postcode.

Performance considerations

Every customisation adds complexity, and complexity can affect performance. The guiding principle for Shopify Plus customisation is: add only what generates measurable value, and measure the performance impact of everything you add.

Functions vs. apps for checkout logic

Functions run as compiled WebAssembly modules with strict execution time limits (5ms). This makes them dramatically faster than equivalent logic implemented through third-party apps, which typically involve API calls, JavaScript execution, and network latency. For any checkout logic that can be implemented as a Function, the performance advantage is significant.

Extension performance

Checkout Extensions run in a sandboxed iframe, which isolates them from the main checkout thread. However, each extension adds rendering time. Keep your extensions lean: minimise API calls within extensions, use static content where possible, and measure the impact on checkout completion rate after deploying each extension.

Flow performance

Flow automations run asynchronously, so they do not affect storefront or checkout performance. However, poorly designed workflows can create cascading actions that overwhelm downstream systems. For example, a Flow that triggers an API call to your ERP for every order might be fine at 50 orders per day but problematic at 500. Design your Flow automations with scale in mind.

Build vs. buy: when to customise and when to use apps

Not every requirement justifies custom development. Apps exist because they solve common problems efficiently. The decision between building a custom solution and using an app should be based on:

Factor	Build custom	Use an app
Requirement uniqueness	Unique to your business	Common across many stores
Performance sensitivity	Critical path (checkout, cart)	Non-critical path (admin, reporting)
Maintenance	You have development resource	You prefer vendor-managed updates
Cost comparison	High upfront, low ongoing	Low upfront, ongoing subscription
Integration depth	Deep, custom integration needed	Standard integration sufficient

In practice, most Shopify Plus stores use a combination: custom Functions for checkout logic, custom Checkout Extensions for the purchase experience, custom theme for brand-specific design, and apps for commodity functionality like reviews, email marketing, and analytics.

Getting started with Plus customisation

If you are on Shopify Plus (or considering the upgrade), here is a practical approach to getting value from the customisation tools:

1. Audit your current workflow pain points. Identify the manual, repetitive tasks that consume your team's time. These are candidates for Flow automation.
2. Analyse your checkout data. Look at checkout abandonment rates, average order value, and conversion rates by device. These metrics identify where Checkout Extensions and Functions can generate revenue impact.
3. Review your discount strategy. If you are using discount codes for promotions that could be automated (tiered pricing, buy-X-get-Y, loyalty discounts), Scripts or Functions can eliminate the friction of manual code entry.
4. Assess your theme performance. Run your store through Google PageSpeed Insights. If your scores are below 80 on mobile, a custom theme built for performance will improve conversion rates.
5. Prioritise by revenue impact. Start with the customisations that have the most direct revenue impact: checkout optimisation, automated discounting, and operational efficiency. Layer in additional customisations as you prove value.

---

Shopify Plus customisation is not about using every tool because you can. It is about selecting the right tools for your specific business requirements and implementing them in a way that generates measurable returns. Scripts and Functions optimise checkout economics. Flow eliminates operational overhead. Checkout Extensions improve the purchase experience. Together, they make your store work harder without adding complexity to your team's daily operations.

If you are on Shopify Plus and want to discuss how these customisation tools can work for your brand, start a conversation with us. We build custom Shopify Plus implementations that leverage Scripts, Flow, and Extensions to drive revenue and efficiency. Explore our Shopify development services for more on our approach.