Custom apps vs marketplace apps and when each makes sense, how the build process works, and what it costs. A practical guide.
TL;DR: Shopify's app ecosystem covers most standard merchant needs out of the box. A custom app makes sense when your business logic is too specific for off-the-shelf solutions, when you need a deep integration with an existing system (ERP, CRM, PIM), or when you're hitting hard limits on what public apps can access.
Most Shopify merchants start the same way: they find an app on the Shopify App Store, install it in two clicks, and move on. That works well — right up until it doesn't.
The moment your business logic becomes specific enough that no app quite fits, you're faced with a choice: bolt together several imperfect tools and manage the overlaps, or build something that does exactly what you need. This guide walks through that decision clearly. We'll cover what custom Shopify apps can and can't do, what the development process looks like, and how to figure out whether a custom app is the right call for your store.
What is a Shopify app?
A Shopify app is software that connects to your store through Shopify's APIs to extend or automate its functionality. Apps can add new features to your admin, automate workflows, integrate with external platforms, surface custom storefronts, or process events in real time via webhooks.
There are three categories worth understanding:
Public apps are listed on the Shopify App Store and available to any merchant. They're built to serve a broad audience, which means they're a good fit for standard needs — loyalty programmes, product reviews, email marketing integrations — but can't accommodate custom business logic or deep integrations with proprietary internal systems.
Custom apps (previously called private apps) are built for a single store and not listed publicly. They have full access to the Shopify Admin API and can be configured to do exactly what your business requires. As of April 2022, Shopify replaced the legacy private app system with custom apps, which are more secure and support more granular permission scopes.
Unlisted (partner-built) apps sit between the two: built by a development partner for a specific client, not published publicly, but distributed via a direct install link. Useful for agencies managing multiple client stores with shared tooling.
When do you need a custom Shopify app?
The honest answer is: less often than you might think. The Shopify App Store has over 10,000 apps, and for most common requirements — abandoned cart recovery, upsells, product bundles, review platforms — there's a well-maintained option that costs a fraction of custom development.
Custom development makes sense when:
Your integration doesn't exist. If you're running a proprietary ERP, a custom warehouse management system, or an internal CRM that no existing app connects to, a custom app is the only way to build that bridge properly.
You need data that public apps can't access. Some Shopify API endpoints are restricted or require specific app permission scopes that generic tools don't request. A custom app can be scoped precisely to what your workflow needs.
You're stitching together too many apps. Three separate apps managing related parts of the same workflow is a common warning sign. Each one adds a subscription cost, a potential point of failure, and a dependency you don't control. A single custom integration often costs less long-term than three annual subscriptions plus the developer time to maintain the overlaps.
You're on Shopify Plus and need checkout extensibility. Shopify Plus merchants have access to Checkout Extensibility — the ability to add custom UI blocks, validation logic, and payment modifications to the checkout flow. These are built as app extensions, not third-party plugins.
You have logic that would be a security risk in a third-party app. Passing sensitive order data, customer PII, or pricing logic through a public app's infrastructure is a real risk that's often underweighed. A custom app with scoped permissions and your own data handling is considerably cleaner.
Types of Shopify apps by function
Understanding what kind of app you need shapes the development approach and timeline significantly.
Admin apps and embedded apps
Admin apps run inside the Shopify admin panel using Shopify's App Bridge. They let merchants interact with custom functionality without leaving the admin — useful for custom order management, bulk operations, product data tools, or any workflow that your team runs day-to-day. These are the most common type of custom app for internal operations.
Storefront and theme extensions
Some apps need to do something visible on the storefront: display custom content blocks, show personalised recommendations, add a custom loyalty widget to the cart. Shopify Theme App Extensions allow this without modifying theme code directly — which means the extension doesn't break when the merchant updates their theme.
Backend automation and webhook apps
These run entirely server-side and respond to events in your store: an order is placed, a product goes out of stock, a customer tags themselves as wholesale. A webhook app listens for these events and triggers actions — updating your ERP, sending a custom notification, applying a discount tier. Often the most straightforward type to build and the most cost-effective for automation-heavy workflows.
Shopify Functions
Shopify Functions are a newer capability that allows developers to customise the core commerce logic that runs on Shopify's infrastructure — discount logic, delivery customisation, payment filtering, order routing. Rather than approximating custom pricing through a frontend hack, Functions let you run the logic where it actually belongs. Available to all merchants, but most powerful on Shopify Plus.
Shopify Sidekick and app development
Shopify's Winter '26 Edition introduced significant AI capabilities under the Sidekick umbrella that are directly relevant to merchants thinking about app development. There are two distinct things to understand: what Sidekick can build on its own, and how custom apps can connect to Sidekick.
What Sidekick can generate itself
Sidekick supports the creation of lightweight internal apps that live directly inside the Shopify admin, support specific operational workflows, and can be refined through follow-up prompts without coding. A merchant can describe a workflow in plain language — "create a tool that flags orders over €500 from new customers for manual review" — and Sidekick will generate a functional admin tool from that prompt.
This is genuinely useful for a specific category of need: simple, internal-facing tools that automate repetitive admin tasks and don't require external API calls or complex data logic. These apps are not designed to replace full-scale custom development for customer-facing features.
The distinction matters. If what you need is a lightweight admin workflow — something a junior developer would previously have spent a few days building — Sidekick may be able to produce a working prototype in minutes. If you need an ERP integration, a custom checkout experience, or anything that passes data between Shopify and an external system, Sidekick is not the right tool. That's still custom development work.
Official limitations of Sidekick app generation
Shopify's own documentation on generating apps with Sidekick makes several things explicit that are worth understanding before you rely on the feature.
Plan availability. App generation is available only on the Grow, Advanced, and Shopify Plus plans. Stores on the Basic plan had temporary access through April 2026, but that access is not permanent. If your store is on a lower-tier plan, this feature may not be available to you at all.
Usage limits apply. Shopify imposes both hourly and weekly limits on app generation. The hourly limit refreshes every hour; the weekly limit refreshes every seven days. This matters for teams that plan to use Sidekick iteratively — you can hit the ceiling while mid-project and have to wait before continuing.
Generated apps can modify customer-facing data. This is Shopify's own caution, not ours: generated apps can change customer-facing data in your store. Shopify explicitly recommends testing the app thoroughly before installing it. For merchants who assume Sidekick-generated apps are sandboxed and safe to install immediately, this is a significant caveat.
Each edit creates a new version, not an editable codebase. When you refine a generated app through follow-up prompts, each change creates a new version. You're working with a series of AI-generated snapshots, not a version-controlled codebase you can audit, test systematically, or hand to a developer to extend. This iteration model works for simple tools but creates compounding uncertainty as complexity increases.
Sidekick App Extensions: connecting your custom app to Shopify's AI layer
The more significant development for anyone building or commissioning a custom app is Sidekick App Extensions, introduced in Winter '26 Edition.
Your app can connect its data and workflows using app extensions. Sidekick can search your app's data, answer questions with your app's context, and take merchants straight to the right page in your app. You can also let Sidekick assist directly inside your app — define safe, scoped actions, and Sidekick will suggest changes and bring up the right UI, but merchants stay in control of what gets updated.
In practice, this means that a well-built custom app can become part of the merchant's natural Shopify workflow rather than a separate system they have to remember to check. When a merchant asks Sidekick a question, it queries across multiple apps simultaneously and returns ranked results with branded cards showing exactly the context they need.
For example: if Eltrino builds a custom ERP integration that syncs order data, a merchant could ask Sidekick "which orders from this week haven't synced to the warehouse yet?" and get an answer sourced directly from the integration — without leaving the Shopify admin.
Shopify began working with partners in Q1 2026 to build out this ecosystem. The Sidekick App Extensions API is currently in developer preview, which means the capability exists and is documented, but the implementation details are still evolving. If you're commissioning a custom app today, it's worth asking your development partner whether building a Sidekick extension layer into the app is worth scoping — for integrations that produce data merchants will want to query regularly, it likely is.
When Sidekick isn't enough: hiring an agency for app development
Sidekick is useful for what it is. The problem is that merchants often discover its limits mid-project — after spending time iterating on a prompt-generated tool that almost works, but not quite.
Here are the specific situations where Sidekick's app generation runs out of runway and custom agency development is the right call.
Your integration requires an external API
Sidekick-generated apps operate within the Shopify admin and work with data that already lives in Shopify. The moment you need to connect to something outside — an ERP, a warehouse management system, a proprietary CRM, a third-party logistics provider — you're in custom development territory. These integrations require authentication flows, error handling, retry logic, and data mapping that Sidekick cannot produce. An agency scopes and builds these integrations properly, which means accounting for what happens when the external API is slow, returns unexpected data, or changes its schema in six months.
You need two-way data sync
Reading data from Shopify and displaying it is one thing. Keeping two systems in sync — orders flowing to your ERP, inventory updates flowing back to Shopify, refunds reflecting in both directions in near real-time — is a different class of problem. Race conditions, duplicate records, and failed webhook deliveries are all routine hazards of sync architecture. A Sidekick-generated tool has no mechanism for handling any of this. A properly built custom app has retry logic, a dead-letter queue for failed events, and an admin interface for resolving exceptions manually when automated handling fails.
The stakes are too high for a prototype
Sidekick's app generation is appropriate for internal tooling where a failure means a team member has to do something manually. It is not appropriate for anything touching live order processing, customer-facing functionality, payment flows, or compliance-sensitive data handling. If the app failing means orders don't fulfil, customer data is exposed, or a payment isn't captured, you need an agency to build and test it properly — including edge cases, failure scenarios, and load conditions.
You need the app to evolve
Prompt-generated apps are difficult to maintain and extend. There is no codebase with clear architecture, no test suite, no documentation. If your requirements change — a new integration, a new data field, a new exception type — you're often better off rebuilding from the prompt than modifying what exists. Custom agency development produces a structured, version-controlled codebase that a developer can read, modify, and extend months or years later without starting from scratch.
You're on Shopify Plus and need checkout-level logic
As covered earlier, Shopify Functions and Checkout Extensibility require proper development work. Sidekick cannot generate a Shopify Function. Dynamic pricing logic, custom delivery rules, payment filtering, and checkout validation all require a developer who understands WebAssembly constraints and Shopify's execution environment — not a natural language prompt.
What to expect from an agency vs. a prompt
The output is different in kind, not just degree. A Sidekick-generated app is a working prototype that handles the expected case. A custom-built app handles the expected case and the unexpected ones — rate limit hits, partial failures, malformed responses from external APIs, concurrent updates, permission edge cases. The difference is invisible until something goes wrong, at which point it's extremely visible.
The practical decision rule: if the app is internal, low-stakes, and doesn't touch external systems, try Sidekick first. If it fails or stalls, you have a clearer brief for an agency. If any of the above conditions apply — external integration, sync, payment logic, compliance, production reliability — start with the agency and skip the detour.
The Shopify app development process
Custom app development follows a consistent pattern regardless of scope. Here's what a typical engagement looks like.
Discovery and scoping
Before writing a line of code, the most important work is defining what the app actually needs to do — not in general terms, but specifically. Which Shopify API endpoints does it need? What external systems does it connect to? What data flows where, and who triggers what?
The scoping phase typically takes 1–2 weeks. For integrations with complex external systems (an ERP with a non-standard API, for example), this phase deserves more time — the cost of getting it wrong at the code stage is orders of magnitude higher than the cost of asking one more question up front.
API and authentication setup
Shopify uses OAuth for app authentication. Custom apps installed on a single store use access tokens rather than the full OAuth flow, which simplifies things considerably. The developer will set up the app in the Shopify Partner Dashboard, configure the required API scopes, and establish the authentication layer before any business logic is written.
Core development
Development is typically structured in sprints, with the integration points with external systems — Shopify API, your ERP or CRM API, webhooks — built and tested first, then the business logic layered on top. Good Shopify development follows Shopify's own App Design Guidelines to ensure the admin experience feels native rather than bolted on.
Testing covers both the happy path (things working as expected) and failure handling — what happens when Shopify's API rate limit is hit, when an external service is unavailable, or when an order comes in with unusual data. Webhook apps in particular need robust retry and logging logic.
Deployment and monitoring
Custom apps are hosted externally — on your own infrastructure or a cloud provider — and connect to Shopify via API. You'll need hosting for the app backend, and a plan for monitoring, logging, and handling app updates as Shopify's API evolves.
Shopify updates its API with new versions twice a year and deprecates old versions on a rolling schedule. Any custom app needs a maintenance plan, not just a launch plan.
Shopify app development cost and timeline
There's a wide range here, and any estimate that doesn't start with a scoping conversation should be treated sceptically.
Simple webhook automation or internal tool: €5,000–€15,000, 3–5 weeks. A custom app that listens to order events and syncs data to an internal system, or an admin tool that automates a repetitive manual workflow.
Mid-complexity ERP or CRM integration: €15,000–€35,000, 6–10 weeks. Two-way sync between Shopify and an external platform, with custom mapping, error handling, and an admin interface for managing exceptions.
Complex integration or custom checkout functionality: €35,000–€80,000+, 10–16 weeks. Multi-system integrations, custom Shopify Functions for checkout logic, or apps with significant admin UI and reporting.
Shopify Plus checkout extensions: Typically within the mid-to-complex range, depending on scope. The checkout is high-stakes and requires thorough testing across payment methods, discount combinations, and edge cases.
These are starting points, not quotes. Scope changes, external API constraints, and the state of the systems being integrated are the biggest variables. The best way to get an accurate number is a structured technical discovery session.
Marketplace apps vs. custom apps: how to decide
This is the question most merchants should actually start with. Custom development is not always the right answer — and the best agencies will tell you that before you spend money.
Use a marketplace app when:
- The functionality is standard and well-served by existing tools
- The app is actively maintained with a good review history
- The cost of custom development clearly exceeds the app subscription cost over 2–3 years
- Your requirement can be met without giving a third-party app access to sensitive data Consider custom development when:
- You've evaluated 3+ marketplace apps and none adequately fits the requirement
- You're integrating with a proprietary or non-standard system
- You need data access or API scopes that no suitable public app requests
- You're on Shopify Plus and need checkout-level customisation
- You're spending more on developer time managing multiple app conflicts than a custom integration would cost A useful middle option: some agencies will extend or configure existing apps as a starting point, rather than building entirely from scratch. If a well-maintained open-source or freemium app covers 70% of your need, sometimes extending it is faster and cheaper than starting from zero.
What to look for in a Shopify development partner
Shopify app development is a distinct discipline from Shopify theme work. The skills overlap but aren't the same — API architecture, webhook handling, error logging, and external integrations require a different background than storefront customisation.
A few things worth checking:
Shopify API experience at the integration layer. Can they describe how they've handled Shopify's API rate limits in production? Have they worked with the Admin API, Storefront API, and webhooks in real projects — not just tutorials?
A process for scoping, not just building. The most expensive custom app projects are ones where the scope wasn't defined properly before development started. A good partner will push back on vague requirements and insist on clarity before committing to a timeline.
Maintenance and version compatibility. Shopify deprecates API versions. Any partner worth working with should have an answer to "what happens when Shopify updates their API in six months?"
Honest assessment of whether you need custom development at all. If a development partner immediately reaches for a custom build without first evaluating whether an existing app covers the requirement, that's a flag. Good advice sometimes means recommending you spend less.
FAQ
Only limited admin apps. Sidekick-generated apps work inside the Shopify admin and can use Admin API data like orders, products, customers, discounts, content, and analytics. They are not customer-facing and can’t work with themes, checkout, customer account apps, or functions outside the Shopify admin.
Shopify deprecated private apps in April 2022 and replaced them with custom apps. Custom apps are more secure, use scoped API permissions (rather than full-store access tokens), and are managed through the Shopify admin under Settings > Apps and Sales Channels. If you're still running a legacy private app, it continues to work but cannot be re-created — new builds should use the custom app framework.
Yes, but the mechanism depends on your Shopify plan. Merchants on Shopify Plus can use [Checkout Extensibility](https://shopify.dev/docs/apps/build/checkout) to add custom UI components, run validation logic, and modify shipping and payment options via Shopify Functions. Standard plan merchants are limited to what's available through theme app extensions and post-purchase flows — direct checkout customisation requires Plus.
A straightforward automation or admin tool typically takes 3–5 weeks. A full ERP or CRM integration — with two-way sync, error handling, and an admin interface — typically takes 6–10 weeks. Complex builds involving Shopify Functions, custom checkout extensions, or multi-system integrations range from 10–16 weeks. Scoping the requirement properly at the start is the most reliable way to compress this timeline.
Simple tools run from €3,000–€15,000. Mid-complexity integrations are typically €15,000–€35,000. Complex builds with checkout logic or multi-system integrations start at €35,000 and go higher. The primary cost drivers are the complexity of the external integration, the number of data flows to handle, and the quality of documentation available for the external API.
Yes. Shopify releases new API versions twice a year and deprecates older ones on a rolling 12–24 month schedule. Any custom app needs to be kept compatible with current API versions, and monitored for errors — particularly webhook apps, where silent failures can mean data stops syncing without anyone noticing. Budget for an ongoing maintenance engagement, not just the initial build.
A custom app is installed on one store by default. If you need the same functionality across several stores (common for Shopify Plus organisations or agencies managing multiple merchant accounts), you can build an unlisted app distributed via direct install link, or a fully public app on the App Store. The architecture differs slightly depending on whether stores share data or operate independently.
Shopify Functions are a specific capability within the custom app framework — they let you run serverless logic on Shopify's own infrastructure to customise commerce operations like discounts, delivery options, and payment filtering. Not every custom app uses Functions; many apps interact with Shopify purely via its external APIs. Functions are specifically useful when you need to modify how Shopify processes transactions, rather than just reading or writing data.
Conclusion
The Shopify App Store covers the majority of standard merchant needs efficiently and cost-effectively. Custom app development is the right choice when your business logic is specific enough, your integration requirements are proprietary, or you're on Shopify Plus and need to own the checkout experience not when it's the first thing someone suggests.
The difference between a successful custom app project and an expensive one usually comes down to scoping. A clear definition of what the app needs to do, which systems it connects to, and what happens when things go wrong is worth more than weeks of development time.
Content
Categories
Shopify App Development Services
If you're weighing up whether a custom Shopify app is the right call for your store. We'll tell you honestly whether custom development is needed.