E-Commerce Platform Development: Custom vs Shopify vs Headless

When a client comes to us wanting to sell things online, the first conversation is never about technology. It is about what they are actually selling, how they are selling it, and what makes their commerce experience different enough to matter.

The answer to those questions determines whether they need Shopify, a headless commerce platform, or a fully custom build. We have done all three. We have also told clients not to hire us and to just use Shopify out of the box. The right answer depends entirely on the situation.

Here is how we think about the decision.

The Three Options

Shopify (hosted platform). You get a storefront, checkout, payment processing, inventory management, shipping, and a theme system. Shopify handles hosting, security, PCI compliance, and uptime. You customize through themes and apps. Monthly cost starts at $39 and goes up with transaction volume and features.

Headless commerce (decoupled frontend + commerce backend). You use a commerce engine like Medusa, Saleor, or Shopify Hydrogen for the backend (products, cart, checkout, inventory) and build a completely custom frontend. You get full control over the user experience while the commerce logic is handled by the platform.

Fully custom (build everything). You build the entire commerce stack: product catalog, cart, checkout, payment processing, inventory, shipping, order management. This is what we did for JustTheRip, a digital pack-opening platform for trading card games, because no existing commerce platform supports gamified purchasing mechanics.

Each option involves fundamentally different tradeoffs in cost, time, flexibility, and ongoing maintenance.

When Shopify Wins

Shopify is the right choice more often than most development studios want to admit. If we are being honest, probably 60-70% of e-commerce businesses should be on Shopify. Here is when:

You are selling physical products with standard purchasing flows. Customer browses, adds to cart, checks out, receives a package. If that describes your business, Shopify has spent billions of dollars optimizing exactly this experience.

Speed to market matters more than uniqueness. You can launch a Shopify store in a week. A headless build takes 4-8 weeks minimum. A custom build takes 8-16 weeks. If you need to be selling by next month, the decision makes itself.

You do not have a development team. Shopify is designed for non-technical merchants. Theme customization, app installation, product management, order processing — all through a GUI. No code required for basic operations.

Your budget is under $20,000. Below this threshold, there is not enough budget to build something custom that is better than what Shopify provides out of the box. Spend the money on marketing instead.

The limitations of Shopify are real but often overstated. The checkout experience is not fully customizable (though Checkout Extensions have improved this significantly). The Liquid templating language has a learning curve. Complex product relationships and custom pricing logic can be awkward. But for standard e-commerce, these limitations rarely matter.

When Headless Commerce Wins

Headless commerce decouples the frontend from the commerce backend. You use a commerce engine for the boring but critical stuff (inventory, cart logic, payment processing, order management) and build a custom frontend for everything the customer sees.

This approach wins when:

Your brand experience is a competitive advantage. If you are a DTC brand where the website experience is part of the product, Shopify themes are not enough. You need full control over every pixel, every animation, every interaction. A headless frontend built with a framework like SvelteKit or Next.js gives you that.

You need to integrate commerce into a larger application. If your product is not a “store” but a platform that includes commerce, headless makes sense. Think of an online learning platform that also sells merchandise, or a media company that sells subscriptions and physical products through the same interface.

You want the best performance. Headless frontends deployed to edge networks (Vercel, Cloudflare) are objectively faster than Shopify storefronts. Sub-second page loads, instant navigation, no theme bloat. For high-traffic sites where conversion rates are sensitive to page speed, this matters.

The commerce backends we have worked with:

Medusa.js is our current recommendation for most headless builds. It is open-source, Node.js-based, and extensible. The data model is flexible, the API is clean, and you can self-host it or use their managed cloud. For a SvelteKit frontend with Supabase auth, Medusa integrates cleanly:

// lib/medusa.ts
import Medusa from '@medusajs/js-sdk';

const medusa = new Medusa({
  baseUrl: import.meta.env.MEDUSA_BACKEND_URL,
  publishableKey: import.meta.env.MEDUSA_PUBLISHABLE_KEY,
});

// Fetch products with server-side rendering
export async function getProducts(categoryId?: string) {
  const { products, count } = await medusa.store.product.list({
    category_id: categoryId ? [categoryId] : undefined,
    limit: 20,
    fields: 'id,title,handle,thumbnail,variants.calculated_price',
  });

  return { products, count };
}

// Add to cart
export async function addToCart(cartId: string, variantId: string, quantity: number) {
  const { cart } = await medusa.store.cart.createLineItem(cartId, {
    variant_id: variantId,
    quantity,
  });

  return cart;
}

Saleor is another strong option, particularly if your team prefers GraphQL. It is Python/Django-based, which means a different operational stack but a mature and feature-rich commerce engine.

Shopify Hydrogen lets you use Shopify as the headless backend with a custom React/Remix frontend. This gives you Shopify’s commerce infrastructure (checkout, payments, inventory) with full frontend control. If you are already on Shopify and outgrowing themes, Hydrogen is the natural next step.

The cost of headless is higher upfront (custom frontend development) and ongoing (you own the frontend hosting, deployment, and maintenance). Budget $30,000-$80,000 for an initial build and $1,000-$3,000/month for hosting and maintenance.

When Custom Wins

Fully custom e-commerce is the most expensive and most flexible option. We recommend it only when the commerce experience itself is the product, and no existing platform can support your model.

JustTheRip is our clearest example. It is a digital pack-opening platform for trading card games. Users buy “packs” and open them to reveal cards, with rarity-based randomization, collection tracking, and a secondary marketplace. None of this maps to a standard e-commerce model:

• Products are not static. A “pack” is a randomized container, not a SKU.
• The purchase experience is gamified. The opening animation is part of the product.
• Inventory is dynamic. Cards are generated from rarity tables, not pulled from a warehouse.
• The secondary market means users are both buyers and sellers.

Trying to build this on Shopify would have meant fighting the platform at every turn. A headless commerce backend would have been equally awkward because the “commerce” logic is inseparable from the application logic.

For JustTheRip, we built:

// lib/pack-opening.ts
interface PackType {
  id: string;
  name: string;
  price: number;
  cardCount: number;
  rarityWeights: {
    common: number;
    uncommon: number;
    rare: number;
    legendary: number;
  };
}

interface Card {
  id: string;
  name: string;
  rarity: 'common' | 'uncommon' | 'rare' | 'legendary';
  imageUrl: string;
  serialNumber: number;
}

async function openPack(userId: string, packTypeId: string): Promise<Card[]> {
  const packType = await getPackType(packTypeId);
  const cards: Card[] = [];

  for (let i = 0; i < packType.cardCount; i++) {
    const rarity = weightedRandom(packType.rarityWeights);
    const card = await generateCard(rarity, packType.id);
    cards.push(card);
  }

  // Record the pull in the user's collection
  await db.insert(userCards).values(
    cards.map((card) => ({
      userId,
      cardId: card.id,
      obtainedAt: new Date(),
      obtainedFrom: packTypeId,
    }))
  );

  return cards;
}

function weightedRandom(weights: Record<string, number>): string {
  const entries = Object.entries(weights);
  const total = entries.reduce((sum, [, w]) => sum + w, 0);
  let random = Math.random() * total;

  for (const [rarity, weight] of entries) {
    random -= weight;
    if (random <= 0) return rarity;
  }

  return entries[0][0];
}

Payment processing still uses Stripe (there is no reason to reinvent that), but everything else — product model, inventory logic, user collections, marketplace transactions — is custom.

The cost of a fully custom e-commerce build is significant. Budget $50,000-$150,000+ for the initial build depending on complexity, and plan for ongoing development because you own every piece of the stack.

The Decision Framework

Here is how we guide clients through the decision:

Is your product a standard physical/digital good?
├── Yes
│   ├── Budget under $20K? → Shopify
│   ├── Brand experience is a key differentiator? → Headless
│   └── Standard purchasing flow? → Shopify
│
└── No (gamified, marketplace, custom pricing, dynamic inventory)
    ├── Can any part map to an existing commerce engine? → Headless + custom modules
    └── Commerce logic is inseparable from app logic? → Fully custom

Most clients are surprised when we recommend Shopify. They come to a development studio expecting us to want to build something custom. But our job is to recommend what is right for their business, not what generates the most billable hours. If Shopify solves the problem, we will say so and help them set it up or refer them to a Shopify specialist.

Common Mistakes

Over-customizing Shopify. If you find yourself writing complex Liquid templates, building multiple custom apps, and fighting Shopify’s data model, you have outgrown the platform. Migrate to headless rather than spending more on workarounds.

Under-estimating headless complexity. Headless gives you freedom, but freedom has a cost. You need to build: product listing pages, search and filtering, cart management, checkout flow, order confirmation, account management, email notifications. Shopify gives you all of this out of the box. Headless means building every screen.

Building custom when headless would work. Custom e-commerce is only justified when the commerce model itself is non-standard. If you are selling normal products with a unique frontend experience, that is headless, not custom. The commerce backend (inventory, orders, payments) is a solved problem.

Ignoring the ongoing cost. Shopify costs $39-$399/month and Shopify takes care of everything. Headless costs $1,000-$3,000/month in hosting and requires developer maintenance. Custom costs $2,000-$5,000+/month in hosting, monitoring, and ongoing development. Factor the three-year total cost, not just the build cost.

Performance Comparison

We ran a direct comparison between a Shopify store, a headless SvelteKit + Medusa build, and a custom build, all selling similar products:

Metric              Shopify    Headless    Custom
──────────────────────────────────────────────────
Time to market      1-2 weeks  6-10 weeks  10-16 weeks
Build cost          $2-5K      $30-80K     $50-150K+
Monthly hosting     $39-399    $50-200     $100-500
Monthly maintenance $0-500     $1-3K       $2-5K+
Page load (LCP)     2.1-3.5s   0.8-1.5s    0.8-1.5s
Customization       Medium     High        Unlimited
PCI compliance      Included   Included*   Your problem

*When using Stripe or the commerce engine’s hosted checkout.

The performance gap between Shopify and headless/custom is real and measurable. For high-traffic sites (100,000+ monthly visitors), a 1-2 second improvement in page load can meaningfully impact conversion rates. For smaller sites, the difference is unlikely to justify the additional cost.

Our Recommendation Process

When a client asks us to build an e-commerce experience, we walk through this process:

1. Understand the commerce model. What are you selling? How is it priced? What makes the buying experience unique?
2. Assess technical requirements. Integrations, custom logic, performance needs, multi-currency, multi-language.
3. Evaluate budget and timeline. Be honest about what each approach costs, including ongoing maintenance.
4. Recommend the simplest option that works. Not the most impressive. Not the most technically interesting. The simplest one that solves the actual problem.

We have told clients to use Shopify. We have built headless storefronts on Medusa. We have built fully custom commerce experiences like JustTheRip. The right answer depends on what you are selling and how you are selling it.

If you are trying to figure out the right approach for your e-commerce project, reach out at hello@threshline.com. We will give you an honest recommendation, even if that recommendation is “just use Shopify.”