What's the difference between a custom app and a public Shopify app?

A custom app is built for one specific store, installed directly, and never listed in the App Store — ideal when you just need to solve your own problem. A public app is distributed to many merchants through the Shopify App Store, which means listing review, billing integration, GDPR webhooks, and support obligations. Build custom when the app is for you; build public only if you intend to sell it as a product.

What tech stack do you need to build a Shopify app?

Shopify's official stack is Remix (Node.js) with the App Bridge library and Polaris for the admin UI, talking to the Admin GraphQL API via OAuth. You store the shop's access token in a database, listen to webhooks for events, and — for anything that must run at checkout — write a Shopify Function in Rust or JavaScript. You can use other frameworks, but the Remix template gives you auth, billing and session handling out of the box.

Should I build a Shopify app myself or hire a developer?

Build it yourself if it's a simple internal tool, you have Node/React experience, and it doesn't touch checkout or money. Hire out anything customer-facing, revenue-critical, or checkout-safe — OAuth edge cases, billing, GDPR webhooks and Functions are where DIY apps quietly break. The cost of a broken checkout dwarfs the cost of doing it right the first time.

How to build a Shopify app (custom vs public, tech stack, build vs hire)

How to build a Shopify app in 2026 — custom (single-store) vs public apps, the Remix/Node + Polaris + API stack, and when to build vs hire it out.

If you’ve hit the ceiling of what themes and off-the-shelf apps can do, the next step is your own. This guide covers how to build a Shopify app end to end: the fork in the road between a custom and a public app, the tech stack Shopify actually recommends, and the honest question underneath all of it — should you build it or hire it out? We build these for a living, so this is written from the implementation side, not the brochure side.

Custom vs public: pick this first

Before a single line of code, decide which kind of app you’re building, because it changes almost everything.

Custom app (single-store). Built for one store, installed directly, never listed publicly. No App Store review, no billing API, no multi-tenant concerns. This is the right answer when you’re solving your own problem — a bespoke integration, an internal dashboard, a workflow no public app handles. It’s dramatically faster to ship.
Public app. Distributed to many merchants through the Shopify App Store. Now you inherit the full weight of being a software vendor: App Store listing review, the billing API, mandatory GDPR/compliance webhooks, multi-shop data isolation, and ongoing support. Only take this on if the app itself is the product you intend to sell.

Most merchants who think they need a public app actually need a custom one. Being honest about that up front saves months.

The tech stack

Shopify’s officially blessed path is a specific stack, and following it means auth, billing and sessions are mostly handled for you:

Remix on Node.js — the framework the official Shopify app template ships with. It gives you OAuth, session storage and webhook scaffolding out of the box.
App Bridge + Polaris — App Bridge embeds your app inside the Shopify admin; Polaris is Shopify’s React component library so your UI looks native to merchants instead of like a bolted-on iframe.
Admin GraphQL API — how your app reads and writes store data (products, orders, customers, metafields). You authenticate via OAuth, store the shop’s access token, and query on its behalf. For the wider picture of connecting Shopify to other systems, see our guide to Shopify API integration.
Webhooks — Shopify calls your app when things happen (order created, app uninstalled, data-erasure requests). Public apps are required to implement the compliance webhooks.
Shopify Functions — for any logic that must run server-side at checkout (discounts, cart transforms, delivery/payment customization). This is the part you cannot fake with theme JavaScript, and it’s what makes an offer checkout-safe. Our own free AOV Bundle app enforces its offers with a Function precisely so the discount can’t be bypassed at checkout.

You can technically use Node without Remix, or another database — but the template exists because the un-fun parts (OAuth handshakes, HMAC verification, token refresh) are easy to get subtly wrong.

What actually takes the time

The tutorial gets you a “hello world” app in an afternoon. Production is the other 95%:

OAuth and session edge cases — reinstalls, token expiry, scope changes.
Rate limits and pagination — the Admin API is metered; a naive sync of a large catalog will get throttled.
Webhook reliability — Shopify retries, but your endpoint must be idempotent and verified.
Billing — if it’s public, the billing API and its test/prod modes.
Checkout-safe logic — anything touching price or eligibility belongs in a Shopify Function, not front-end JS a shopper can disable. This is the single most common place DIY apps break: an offer that looks right on the product page but doesn’t hold at checkout.

Build vs hire

Here’s the straight answer.

Build it yourself if: it’s a simple internal/custom app, you’re comfortable with Node and React, and it doesn’t touch checkout, money, or customer data at scale. A custom app that reformats data or automates an internal task is a great learning project and genuinely doable solo.

Hire it out if: the app is customer-facing, revenue-critical, public, or needs to be checkout-safe. OAuth corner cases, the billing API, GDPR webhooks and Functions are exactly the areas where “it works on my machine” turns into lost orders in production. The economics are simple — a broken checkout costs more per day than the whole build. If you want to sanity-check which side of that line your idea falls on, that’s what a discovery call is for.

The bottom line

Decide custom vs public first, use Shopify’s Remix + Polaris + Admin API stack so the plumbing is handled, and push anything that must survive checkout into a Shopify Function. Build the simple, internal stuff yourself; hire out the parts where a bug means lost revenue. Knowing which is which is most of the battle.

Not sure whether your idea needs a custom app, a public app, or just a Function? Start with a free profit audit — we’ll tell you the smallest thing that actually solves your problem before you spend a cent. Or see what real custom apps and Functions work involves.