By Stack Architect · Updated September 2026 · ~10 min read

Sourced cost ranges · Fair on when custom is right · Not a hit piece

What a custom Shopify app
actually costs,
and when it isn't the answer.

A custom Shopify app is worth commissioning when the requirement is genuinely proprietary rather than a gap an existing tool fills. Build cost is only the first payment: maintenance, API version upgrades and hosting continue indefinitely and are the costs most people forget to budget. For tracking, inventory, email and reporting, a free Make.com scenario does the same job.

Costs sourced from published pricing guides API and App Store facts from shopify.dev Concrete examples, not a generic "it depends"

Jump to the decision framework Calculate your app costs

Already know you want the free route? Read the recommended stack and the Make.com for Shopify setup guide.

$5k–$200k+

Full build cost range

Yearly

Maintenance on top

Every 3 mo

Shopify API versions

The Make.com route

Sourced ranges

What custom Shopify app development actually costs

Prices vary hugely by scope and who builds it. Here's the actual range, not a single misleading number.

"How much does a Shopify app cost" doesn't have one answer, because a private single-store tool and a public App Store product are different projects with different requirements. The ranges below come from published 2026 Shopify development pricing guides: treat them as market estimates, not fixed prices; agency day rates in particular vary by region and specialism.

Project type	Build cost	Notes
Simple private app	$5,000–$15,000	Single-store internal tool: a webhook receiver, a basic admin extension.
Substantial private app	$15,000–$60,000	Multiple features, several API integrations, a real admin UI, data storage.
Public App Store MVP	$30,000–$80,000	Plus $20,000–$50,000 in first-year operations: review, support, hosting.
Substantial public app	$80,000–$200,000	Plus $50,000–$150,000 first-year operations at that scale. Complex platform-style public apps run $200,000–$1,000,000+.

Freelance vs agency rates

Freelance Shopify developers commonly charge about $25–$160/hour, with senior Shopify Plus specialists at $120–$200/hour and offshore developers toward the bottom (CartCoders). Agencies run considerably higher (Shop Experts): boutique shops around $150–$350/hour, established Shopify Plus agencies $250–$500/hour, and enterprise consultancies $400–$800+/hour. A freelancer and an agency building the identical spec can land 3–5x apart purely on who you hire, before scope even changes.

In-house

Hiring a developer directly avoids per-project markup but carries its own math: a mid-level Shopify developer salary plus employer costs typically lands in a similar or higher annual range than commissioning 2–3 substantial private-app projects from an agency; the trade-off is ongoing capacity versus one-off delivery, not a cheaper unit cost.

Sources

Build and maintenance ranges are from Shop Experts' 2026 Shopify App Development Cost guide (its table and FAQ; the summary at the top of that guide gives a wider $30,000–$150,000 for a public MVP), and freelance rates and active-store retainers from CartCoders' Shopify Developer Cost breakdown. We read both on 25 September 2026. Both are third-party agency pricing guides, not Shopify's own pricing: treat the figures as directional market ranges rather than quotes.

Easy to underbudget

The ongoing costs people forget

The build quote is rarely the full cost. Four recurring line items most quotes don't surface upfront.

Maintenance

Ongoing maintenance is a recurring yearly cost on top of the build, often charged as a flat retainer: light upkeep for a private app runs roughly $3,000–$15,000/year (Shop Experts), while an actively-developed store's retainer commonly runs $2,000–$10,000+/month (CartCoders). A public app retainer runs higher still, commonly $5,000–$40,000/month, because it has to keep working across every merchant who installed it, not just one store.

Shopify API version migrations

Shopify ships a new API version every three months. Each stable version stays supported for a minimum of 12 months, with at least nine months of overlap before the previous version is retired, so nothing breaks without warning, but a custom app that nobody revisits will eventually stop working once its version's support window closes. That's recurring engineering time baked into owning custom code, not a one-time cost.

9 mo

Minimum overlap window between Shopify API versions before the old one is retired: the real deadline for migration work on a custom app, per Shopify's own versioning documentation.

App Store review (public apps only)

A public app moves through Draft → Submitted → Reviewed → Published. Shopify's guidance and community reports put the initial review at roughly 4–10 business days; if the reviewer requests changes, common on a first submission, the app is Paused until resubmission, and the full process commonly stretches to 2–4 weeks. Any meaningful functionality change can trigger re-review, which is real calendar time on top of the build.

Hosting

A Shopify app needs somewhere to run: a backend server handling OAuth and webhooks, plus a database. For a low-traffic private app this is modest, often a small managed instance. For a public app serving many stores, hosting cost scales with install volume and becomes a genuine line item, not an afterthought.

Why this matters for the build-vs-compose decision

A $15,000 build quote that omits maintenance, migrations, and hosting isn't really a $15,000 decision: those costs can add a large share of the build price again over three years. Compare the full three-year number, not the initial quote, against the alternative.

Genuinely fair

When custom development is genuinely the right call

This isn't a case against custom apps. Some requirements need one: here's how to recognise them honestly.

Proprietary business logic. A custom pricing engine, a bespoke allocation algorithm, anything unique to how your business actually operates that no existing app or automation module was built to express.
Deep integration with a system that has no accessible API. True real-time, bidirectional sync with an internal ERP or warehouse system that a workflow tool like Make.com simply cannot reach.
You're building a product, not a fix. If the plan is to list the app on the Shopify App Store and sell it to other merchants, the whole cost calculation in this guide doesn't apply: it's not overhead to minimise, it's the business.
Scale beyond what automation platforms sustain. A very large store with sub-second performance requirements or event volume that would exceed a workflow tool's rate limits genuinely needs dedicated infrastructure.
Data residency or compliance requirements that rule out routing data through a third-party automation platform, common in regulated industries.

If your situation matches one of these, the sourced cost ranges above are the right way to budget the project, and the ongoing-costs section is the right way to make sure the quote you accept reflects the real three-year number.

The other case

When a Make.com composition does the same job

Most Shopify integration requests reduce to one pattern: receive a webhook, transform the data, call an API. That's exactly what these free builds do.

A large share of what gets commissioned as a "custom Shopify app" is really a small backend service: listen for a Shopify webhook, reshape the payload, send it to another system. That is precisely what Make.com's Webhooks + transform + HTTP-request module chain does: hosted, maintained, and running on Make.com's infrastructure instead of a bill you pay a developer to build and someone to keep alive.

What it does	The custom-build equivalent	The free composition
Server-side conversion tracking	A backend service receiving order webhooks and POSTing to Meta/Google Conversions APIs: typically $5,000–$15,000+ to build	CAPI Shield: $0, deploys in 6 minutes. Covers Meta; its Google branch cannot match Shopify orders as shipped
Inventory sync to a ledger	A custom order-webhook-to-database sync service	Stocky Swap: $0, a ready-to-import Make.com scenario
Live profit & loss reporting	A custom reporting/BI backend aggregating order data	Shopify P&L Automation: $0
Document generation at volume	A custom document-generation microservice replacing Apps Script	Autocrat Quota Fix: $0
TikTok server-side events	A backend service POSTing to TikTok's Events API	TikTok Events API: $0

The pattern across all five: none of them required a developer, a hosting bill, or App Store review, because they're private automations running on Make.com's already-hosted, already-maintained platform, not public apps at all. What you give up is full control over the code and a dependency on Make.com's uptime instead of your own. For the webhook-transform-API pattern specifically, that trade-off is usually a clear win.

Decision framework

Five questions, in order. Most decisions resolve by question two or three.

Does an existing tool already do 90% of it?

Search for an existing Shopify app, a Shopify Flow, or a Make.com scenario that covers most of the requirement. If one exists, compose it: don't commission a custom build for something already solved.

Is the logic genuinely proprietary?

If the requirement is business logic unique to your operation, or true bidirectional real-time sync with an internal system that has no accessible API, that's a real signal for custom development.

Are you building a product, not a fix?

If the app is meant to be sold on the Shopify App Store to other merchants, this is a product decision, not a cost-avoidance one: build it.

Have you priced the full three-year cost?

Add first-year maintenance, API migration time, and, for public apps, App Store review and any retainer, to the build quote before comparing it to anything else.

Prototype it in Make.com first, even if you'll rebuild custom

Building the workflow in Make.com first is free and fast, and tells you exactly what a custom version needs to do: turning a vague spec into a precise one before anyone gets paid to build it blind.

Some links below are affiliate links (marked sponsored). They fund the free guides and never change a recommendation: our default pick on this page is a free tier. How we test & disclose →

Read the Make.com setup guide Prototype it on a free Make.com account

Where to go next

Decided against custom? Here's the free route.

Free tool

App Cost Calculator

Before commissioning anything new, see what your current app stack is already costing: most stores find real waste before they've spent a dollar on custom work.

Free: instant results Reference

The Recommended Stack

Seven vetted free tools covering tracking, inventory, email, and reporting: the composition that replaces most "custom app" requests before they're commissioned.

$0 total Setup guide

Make.com for Shopify

The platform underneath every composition in this guide. Complete beginner's setup: connect Shopify, build your first scenario.

Free tier available Worked example

Google Sheets Automation

A full worked example of the exact webhook-transform-write pattern this guide describes: orders and inventory, real scenario structure, no code.

Free

Common questions

Frequently asked questions

How much does a custom Shopify app cost in 2026?

A simple private app (single internal tool) runs roughly $5,000–$15,000. A substantial private app with multiple integrations runs $15,000–$60,000. A public App Store app MVP runs $30,000–$80,000 to build, plus $20,000–$50,000 in first-year operations. Those are Shop Experts' ranges, read on 25 September 2026; see the sourced breakdown above for the full range by project type.

What's the cost difference between a private app and a public app?

A private app only needs to work for your own store, so it skips App Store review, public-app security requirements, and multi-tenant architecture: most of why private apps cost a fraction of public ones. A public app also carries an ongoing retainer, commonly $5,000–$40,000/month, because it has to keep working for every merchant who installs it.

What ongoing costs does a custom Shopify app have beyond the build?

Four recurring costs people underbudget: maintenance (a yearly cost on top of the build, or a $2,000–$10,000+/month retainer for an active store), Shopify API version migrations (mandatory testing roughly every quarter), App Store re-review for public apps when functionality changes, and hosting for the backend server and database.

How often does Shopify's API change, and does that affect a custom app?

Shopify ships a new API version every three months, with each stable version supported for a minimum of 12 months and at least nine months of overlap, so nothing breaks overnight, but an untouched custom app eventually stops working once its version's support window closes. See Shopify's versioning docs.

How long does Shopify App Store review take?

Roughly 4–10 business days for the initial review. If changes are requested, common on a first submission, the full process commonly stretches to 2–4 weeks. This only applies to public apps; private apps for your own store skip review entirely.

When should I build a custom app instead of using Make.com?

When the logic is genuinely proprietary, when you need true real-time bidirectional sync with a system that has no accessible API, when you're building the app to sell as a product, or when your scale exceeds what a workflow platform's rate limits can sustain. Outside those cases, an existing tool or a Make.com scenario usually gets there faster and cheaper.

Can Make.com really replace a custom-built Shopify integration?

For the common case (receive a webhook, transform the data, send it somewhere else) yes. That's exactly what CAPI Shield, Stocky Swap, and P&L Automation do, each replacing what would otherwise be a small custom backend, at $0. It doesn't replace custom development for logic a workflow tool genuinely can't express.

Is a free Make.com scenario really equivalent to a paid custom app?

For webhook-in, transform, API-out workflows, functionally yes: the underlying mechanism is identical to what custom backend code would do. What you give up is full control over the code, trading it for a dependency on Make.com's platform instead of your own infrastructure. For most Shopify operators that trade-off favours the free composition.

Written by Luke Sandelands

Founder, Stack Architect · Shopify Automation Specialist

Developer of StockLog and author of the open-source shopify-capi-validator npm package. Builds Shopify server-side tracking, Meta CAPI and Google Apps Script automations.

Full profile

Updated 25 September 2026