Beyond Shopify: When E-commerce Brands Need Custom Development

Short answer: move beyond Shopify when platform and transaction fees grow large, when you need custom checkout, subscriptions, or B2B pricing the platform blocks, or when you want to own your storefront — and go headless with Medusa or Saleor so a custom front end pairs with a commerce engine you control.

Shopify and WooCommerce are excellent starting points. They let new brands get to market quickly without a large upfront investment in engineering. But growing brands eventually hit limits: rising fees, rigid checkout, and a storefront they don't fully own. Here's how to know when it's time to move — and what to build instead.

The good news is that the headless commerce ecosystem has matured significantly. Open-source platforms like Medusa have made it realistic for brands doing meaningful volume to own their commerce infrastructure without betting millions on a custom build from scratch.

Signs you've outgrown your platform

The decision to move isn't always obvious. Most brands feel friction long before they can name it precisely. These are the clearest signals.

• Transaction fees are a meaningful line item that scales with your revenue.
• You need custom checkout, bundles, subscriptions, or B2B pricing the platform won't do cleanly without a costly workaround.
• Your storefront performance (Core Web Vitals) is capped by the theme and app stack — you're fighting the platform to hit your speed targets.
• You're blocked from a custom customer experience or unique fulfillment logic that your operations require.
• You want to own your data and storefront, not rent them from a vendor who can change terms, raise prices, or sunset features.
• Your app stack has grown unwieldy — you're paying for five separate apps to do what one integrated system should handle.

If two or more of these apply, it's worth running the numbers on what a custom headless build would cost versus what you're paying the platform today. Our guide on custom software costs covers how to structure that analysis.

What "going headless" means

Headless commerce splits the storefront from the commerce engine. You build any front end you want — fast, custom, SEO-tuned — and connect it via API to a system that handles catalog, cart, orders, and fulfillment logic.

This matters because Shopify's theme architecture tightly couples your storefront to their rendering system. That coupling is what limits your performance ceiling and your ability to build truly differentiated checkout flows. Headless breaks that coupling.

The two open-source platforms we work with most:

• Medusa — open-source headless commerce for B2C and B2B. Strong plugin ecosystem, active maintainers, and genuinely flexible.
• Saleor — GraphQL-native, strong for complex catalogs with lots of variants, attributes, and multi-channel requirements.

Both are self-hostable, so there's no per-transaction platform fee — you pay for hosting, not a percentage of revenue. For a brand doing real volume, that difference compounds quickly.

The front end is typically built with a modern JavaScript framework (Next.js, Astro, or TanStack Start) that delivers excellent Core Web Vitals scores — which directly impacts SEO and paid media conversion rates.

The trade-off: platform vs. custom headless

Before committing to a custom build, decision-makers should understand the honest trade-offs on both sides.

	Shopify / WooCommerce	Custom headless
Time to first sale	Days to weeks	Weeks to months
Platform / transaction fees	Yes, scales with revenue	None (self-hosted)
Checkout flexibility	Limited by platform rules	Full control
Storefront performance ceiling	Theme-bound	Excellent
Data ownership	Partial — vendor holds it	Full
Engineering overhead	Low (managed)	Moderate (your team or partner)
Custom integrations	App store + workarounds	Direct API integrations
B2B pricing / wholesale	Add-on or workaround	Native, if you build it

The trade-off is real: managed platforms handle the operational burden so your team doesn't have to. Custom headless gives you control and lower fees at scale, but requires a build and ongoing engineering ownership. Neither answer is universally right — it depends on your volume, your roadmap, and your team's capacity.

When B2B requirements change the calculus

Standard e-commerce platforms are designed around B2C — a single price list, a cart, a checkout. The moment you add B2B requirements, the calculus shifts sharply in favor of custom.

B2B pricing complexity that platforms handle poorly includes:

1. Customer-specific pricing tiers (different price lists per account)
2. Quote-based ordering workflows where a cart needs approval before purchase
3. Net-30/60/90 payment terms instead of immediate card capture
4. Per-account credit limits and purchase order integration
5. Multi-location ordering with per-location shipping and billing addresses

Shopify Plus can do some of this — but the moment you layer two or three of these requirements together, you're either building elaborate workarounds or paying for a dedicated B2B platform. A headless build with Medusa handles all of these natively because you define the pricing and checkout logic yourself.

If your business sells to both consumers and business accounts, a custom build that serves both from a single commerce engine is often cleaner and cheaper than running two separate platforms.

Subscriptions, bundles, and non-standard checkout flows

Subscriptions represent another category where Shopify's constraints show quickly. The platform supports basic subscriptions through third-party apps, but any complexity — skip logic, pause flows, mid-cycle upgrades, multi-product bundles with differential pricing — becomes expensive and brittle.

A custom headless build can model your subscription logic precisely, because the subscription state lives in your database, not inside an app vendor's system. This also means you can automate dunning, upgrade prompts, and cancellation flows in ways that connect to your CRM and email platform without API gymnastics.

Bundle pricing faces similar constraints. Platforms like Shopify represent a bundle as a product variant, which works until you need dynamic bundle composition (let the customer pick any three from a list), weight-based pricing adjustments, or fulfillment routing that splits a bundle across warehouses. These are all solvable in a custom build because you control the cart calculation and order creation logic.

For brands where subscriptions or bundles are a meaningful revenue line, owning the commerce logic is often the right call. We've also found that custom builds integrate cleanly with workflow automation — connecting order events to fulfillment, CRM, and finance systems via tools like n8n.

Storefront performance and SEO

One underappreciated reason brands move to headless is storefront performance. Shopify themes — even well-optimized ones — carry JavaScript overhead from the Liquid templating system and the app stack. Every installed app can add weight to your storefront.

For brands investing in organic search, storefront performance matters directly. Google's Core Web Vitals (LCP, CLS, INP) are ranking signals, and a storefront that loads slowly or shifts layout during load loses both rankings and conversion rate.

A custom front end built with a modern React or Astro framework and deployed to a CDN edge network routinely scores in the top percentile on Core Web Vitals because:

• You control exactly what JavaScript loads and when
• There's no app-injected script overhead
• Images and assets are optimized at build time
• Server-side rendering and edge caching are handled cleanly

The SEO gains from a faster, cleaner storefront are compounding. They accumulate over months, not overnight — but for brands where organic is a meaningful acquisition channel, this is a real business case, not just a technical preference.

Integrations: owning your data stack

Most e-commerce brands operate a stack of tools alongside their storefront: a CRM, an ERP or inventory system, a warehouse management system, a returns platform, email and SMS providers, and an analytics stack. The more tools you have, the more important it is that your commerce platform can integrate cleanly.

Managed platforms connect to these tools through the app marketplace — which means you're depending on third-party app developers to maintain integrations, and you have limited control over how data flows between systems.

A custom headless build means your integrations are first-class code in your own codebase. You control the data model, the sync frequency, and the error handling. When your ERP returns an unexpected response, you can handle it gracefully rather than waiting for an app vendor to release a fix.

We build these integrations as part of our headless commerce work — connecting Medusa to inventory systems, CRMs, fulfillment providers, and payment processors like Stripe. Our Stripe integration guide covers the payment side in detail, and our API-first architecture post explains why building these connections cleanly from the start saves significant cost over time.

The migration path: you don't have to rebuild everything at once

Moving off Shopify doesn't have to be a big-bang rewrite. A phased migration reduces risk and lets your team validate assumptions before committing fully.

A common pattern we use:

1. Audit your current platform. Identify what's genuinely working (product catalog structure, fulfillment workflows) versus what's painful (checkout constraints, app sprawl, fees).
2. Start with the storefront. Build a new headless front end that pulls from Shopify's Storefront API. This gives you full control of the customer experience and performance without migrating the commerce engine yet.
3. Migrate the commerce engine. Once the storefront is stable, cut over to Medusa or Saleor for catalog, cart, and order management. Migrate your product data, customer records, and order history.
4. Decommission the old platform. Only after the new stack is stable under real traffic.

This approach keeps revenue flowing throughout the migration, limits the blast radius of any single phase, and gives your team time to learn the new system before it's fully live. For teams concerned about data migration risk, our data migration playbook covers how to sequence this safely.

What a custom e-commerce build actually costs

The honest answer is: it depends on scope, but custom headless is not a small investment. The right way to think about it is total cost of ownership over three to five years — not just the build cost.

Typical cost drivers:

• Storefront design and front-end development
• Commerce engine setup and configuration (Medusa or Saleor)
• Custom checkout and pricing logic
• Integration work (ERP, CRM, fulfillment, payments)
• Migration of product data, customer records, and order history
• Hosting infrastructure and ongoing maintenance

What you get in return:

• No per-transaction platform fees (the savings can be significant at volume)
• Full ownership of your storefront, data, and customer relationships
• Engineering freedom to build the checkout and pricing logic your business actually needs
• A performance ceiling determined by good engineering, not platform constraints

For a detailed look at how to evaluate build vs. buy decisions in general, see our post on custom software vs. off-the-shelf. The same framework applies here.

One thing worth flagging for growing brands: if you're not sure whether custom is right for your stage, the signs your business has outgrown off-the-shelf software post is a useful self-assessment.

Key takeaways

• Shopify and WooCommerce are the right starting point for most brands — but platform fees, rigid checkout, and performance ceilings become real constraints at scale.
• Headless commerce (Medusa, Saleor) pairs a custom storefront with a commerce engine you own and self-host, eliminating per-transaction platform fees.
• B2B pricing, subscription logic, and custom bundles are strong drivers for custom development — these use cases strain managed platforms quickly.
• Storefront performance on a custom headless build is significantly better than on a theme-based platform, which compounds into SEO and conversion gains over time.
• A phased migration reduces risk: start with the storefront, then migrate the commerce engine once the new front end is stable under real traffic.
• The right question is total cost of ownership over three to five years, not just the upfront build cost.

Outgrowing your platform? Tell us your volume and roadmap and we'll map the headless path that fits your timeline and budget.