Shopify Functions vs. custom development: Where are the real limits?

If you operate a B2B online store on Shopify Plus and are pondering the question "what do we actually need to customize," you have probably come across two opposing answers.

The first: “Shopify Plus handles this natively, why pay for custom dev."

The second: “Shopify is not a B2B platform, you need a custom system."

The truth is, as usual, somewhere in between — and the exact location of that boundary depends on the size and complexity of your B2B model.

This article aims to specifically name that boundary: what Shopify Plus handles natively and well, where the real technical limits of Shopify Functions are, and when custom development stops being a luxury and becomes a necessity.

What Shopify Plus B2B handles without a single line of custom code

This is a section that many consultants and agencies skip — either because they are unaware of it or because they prefer to sell custom development. We will say it straight.

Shopify Plus includes a native B2B module that systematically expands its capabilities since 2022. According to Shopify's official documentation, it covers these scenarios without the need for external applications or custom development:

1. Individual pricing (Catalogs) — you can assign a custom catalog with individual prices and discounts to each business location. Each location can have up to 25 catalogs assigned simultaneously. If you sell to 500 B2B clients with different pricing levels, Shopify can handle it natively — provided that you manage and synchronize pricing directly in the Shopify admin or through the API.
2. Payment terms — Net 30, Net 60, Net 90 are natively included in the B2B checkout. Customers can choose deferred payment, optionally save a card for automatic deduction on the due date. No custom module is required.
3. Buyer portal — B2B customers have access to a dedicated portal with an overview of orders, quick bulk ordering, and account management. Company profiles support multiple contacts with various permissions (approver, purchaser, view-only).
4. Volume discounts and quantity rules — minimum quantities, price breaks for large orders, packaging — all configurable directly in B2B catalogs without code.
5. Tax exemptions — assignment of tax exemptions at the company or location level.

For a growing mid-market B2B online store — such as a distributor with several hundred clients and standardized pricing — this is sufficient. And when these needs are covered natively, Shopify Functions come into play as an additional layer of logic — not as a patch for missing features.

What Shopify Functions are and what they can really do

Shopify Functions are server-side extensions that run directly in Shopify's infrastructure using WebAssembly. The merchant (or their development team) writes a function in Rust or JavaScript, compiles it into Wasm, and Shopify executes it at defined moments in the purchasing process.

According to the official documentation, these extensions cover:

• Discounts — custom logic for product, order, and shipping discounts beyond native catalogs
• Delivery — filtering, renaming, and sorting shipping methods based on cart content
• Payments — displaying or hiding payment methods based on conditions
• Cart transforms — bundling products into bundles or breaking them apart
• Checkout validation — custom rules before completing an order
• Order routing — directing orders to warehouses or fulfillment centers

Where Functions work reliably and without unnecessary complexity: custom logic for tiered discounts beyond catalogs, hiding cash on delivery for B2B segments, conditional display of shipping methods, bundle logic, validations before checkout.

Technical limits of Shopify Functions: Real numbers

Shopify Functions do not run without restrictions. Here are specific limits that the Shopify developer community and official documentation document:

• Instruction limit: 11 million — each function can execute at most 11 million WebAssembly instructions. For simple price calculations, that is more than enough. With complex logic involving a large number of SKUs and customer combinations, this limit becomes a real barrier — developers often encounter it when working with cart transform functions for larger carts.
• Input limit: 128 kB — input data that Shopify passes to the function can be a maximum of 128 kB (Shopify recently increased this limit from 64 kB). Metafields exceeding 10,000 bytes are not included in the input at all.
• Performance under 5 ms — a function must complete its work within 5 milliseconds. For most calculations, this is sufficient, but it also determines which languages are practical: Shopify recommends Rust, which compiles directly to Wasm and is significantly more efficient than JavaScript.
• No access to external APIs — with exception — this is the most important point and also the most frequently misrepresented. By default, Shopify Functions cannot call external APIs during runtime. There is a feature called Network Access that allows this — however, it is only available for custom applications installed on Shopify Plus and Enterprise plans and requires explicit permission from Shopify. It is not available in dev stores or the standard developer preview.

Where Shopify Plus B2B hits the ceiling

Let’s return to the native B2B module. There are scenarios where even Shopify Plus with Functions falls short — and where waiting for the next platform update is not a business strategy.

Approval workflows — Shopify B2B does not natively support multi-level order approval. If your corporate customers require that orders above a certain value be approved by a supervisor before being submitted, or if you need to assign spending limits to individual purchasers within the company, this is not natively available. It can be handled by third-party applications or custom logic, but not natively.

Real-time pricing from ERP — Shopify B2B pricing works on the principle of synchronization: prices from the ERP system (SAP, Helios, Navision, Pohoda) must be imported into Shopify beforehand. If prices change in real-time — for example, based on current raw material costs or interbank exchange rates — Shopify does not natively support live fetch from ERP. You need either middleware that synchronizes prices with acceptable latency, or a custom pricing API layer.

Credit limit management — management of credit limits for B2B clients (blocking orders when exceeding debt, showing remaining credit balance) is not part of the native B2B module. This is a standard request from distributors and wholesalers that requires integration with the accounting system.

Complex front-end customization — the Shopify front-end is closely tied to the backend. If your B2B customers expect specific UX logic — for example, bulk upload of orders via CSV with SKU validation, hierarchical display of products according to internal categorization of the client, or integration with their procurement system — this level of customization requires custom development, or potentially headless architecture through Shopify Hydrogen.

Real-world example: Where the line is drawn

Imagine two manufacturers of industrial components:

Company A has 300 B2B clients, three pricing tiers (gold, silver, standard), payment terms Net 30, and a standard product catalog with 800 SKUs. Shopify Plus B2B natively handles 90% of their requirements. Shopify Functions complement the logic of shipping methods and validation of minimum order. Custom development is not justified here.

Company B has 4,000 B2B clients, each with an individual contractual price tied to ERP, credit limits, multi-level approval, and a requirement to display real-time availability from WMS directly on the product page. Here, Shopify Plus B2B is insufficient — not because it is bad, but because this level of complexity was designed for dedicated B2B platforms or custom solutions.

The difference between these two companies is not size — it is the depth of integration and the degree of individuality of each customer relationship.

Common decisions mistakes

“Custom dev is always more expensive" — it depends on the time horizon. A native solution with a lot of workarounds can cost more in internal time and technical debt over a year than a one-time custom module.

“Shopify Functions will solve it" — Functions are a layer of logic, not a replacement for missing infrastructure. If your problem is in data architecture (prices live in ERP and not in Shopify), Functions won’t solve it — they will only complicate it.

“We will wait, Shopify will come through” — the Shopify B2B module is evolving rapidly and by 2025 will cover significantly more than two years ago. But some architectural limitations (real-time ERP, credit management, complex approvals) are structural — not just missing features.

Confusing Checkout Extensions and Functions — Checkout Extensions address UI (custom fields, banners, blocks in checkout). Functions address logic (what gets calculated, displayed, validated). They are different layers, and correctly understanding their interrelationship will save a round of unnecessary pre-planning.

Conclusion: The right question is not “Shopify or custom”

Most B2B merchants on Shopify Plus do not need custom development instead of Shopify — they need custom development alongside Shopify. They use the platform for what it can do natively (pricing, payment terms, buyer portal, checkout logic), and custom development or middleware fills in where the platform hits architectural ceilings.

Therefore, the right question is not “Shopify or custom development,” but “where exactly lies the boundary in my specific case and what will it cost us to ignore it?”

If you are looking for an answer to this question for your project, at METINAS we will happily assess your current stack and propose an architecture that will grow with your business — not slow it down.