The Shopify Ecosystem in Numbers
The Shopify App Store is an ecosystem that most people underestimate. Over 12,300 apps are currently available -- and roughly 250 new ones are added every month. The developer community has earned more than 1.5 billion dollars since the App Store's inception, with 1 billion dollars paid out to app developers in 2024 alone.
87% of all Shopify merchants use apps to extend their store. On average, a merchant installs 6 apps -- some as many as 30.
Yet there is a large gray area: many merchants need functionality that no off-the-shelf app provides. Custom workflows, specific ERP integrations, industry-specific logic. This is where custom Shopify app development comes into play.
What Fundamentally Changed in 2025
The Shopify ecosystem evolves rapidly. Anyone building an app with 2023-era knowledge is going to run into problems. Here are the most important changes:
GraphQL Is Now Mandatory
As of April 1, 2025, all new apps submitted to the Shopify App Store must use the GraphQL Admin API. The REST API has not been shut down yet, but Shopify is investing exclusively in GraphQL.
What this means: GraphQL is no longer optional. And there are good reasons for that:
- Shopify processes over 1 million GraphQL queries per second
- Over the past 12 months, Shopify has doubled rate limits and reduced the cost of queries with connections by 75%
- GraphQL exclusively supports new features like 2,000 product variants (versus 100 with REST) and Metaobjects
- GraphQL is a true superset of the REST API -- everything REST can do, GraphQL can do too (and more)
For existing apps: REST still works for now, but the pressure to migrate is mounting. New features are only being built for GraphQL.
From Remix to React Router
Shopify has transitioned its CLI app stack from Remix to React Router v7 (starting with the 2025-10 API version). This sounds more dramatic than it is -- React Router v7 is essentially the successor to Remix (the projects have merged). But it signals Shopify's direction: away from proprietary frameworks and toward established standards.
Checkout Extensibility: The New Normal
Since January 6, 2025, Shopify has begun automatically upgrading stores from checkout.liquid to Checkout Extensions. The old checkout system is being phased out. For app developers, this means:
- Checkout UI Extensions are the only way to customize the checkout
- Extensions can be inserted at defined points: product info, shipping, payment, order summary
- Up to 4 different color schemes can be configured
- Shopify handles updates, bug fixes, and security patches for the checkout
The upside for developers: less maintenance. Shopify takes care of the checkout infrastructure. The downside: less control. You can only hook into the predefined extension points.
Checkout Extensibility has shown a 1% higher conversion rate in tests compared to the old checkout.liquid system -- that is significant.
The Technology Decisions
The Recommended Stack for 2025
| Layer | Technology | Why |
|---|---|---|
| Framework | React Router v7 (formerly Remix) | Shopify standard, best integration |
| UI | Shopify Polaris + App Bridge | Consistent Shopify admin experience |
| API | GraphQL Admin API | Mandatory as of April 2025 |
| Auth | Shopify OAuth + Session Tokens | Standard, preconfigured by Shopify CLI |
| Database | PostgreSQL + Prisma ORM | Robust, well-documented |
| Hosting | Vercel, Railway, or Fly.io | Easy deployment, great DX |
| Storefront | Storefront API (if needed) | For customer-facing integrations |
| Serverless Logic | Shopify Functions | Custom Discounts, Shipping, Payment |
The API Landscape
| API | What It Does | Typical Use Case |
|---|---|---|
| Admin API (GraphQL) | Full access to store data | Manage products, orders, customers |
| Storefront API | Read access to store data | Frontend widgets, headless commerce |
| Checkout Extensions | UI customizations in checkout | Additional fields, upsells, custom UI |
| Shopify Functions | Serverless logic | Custom discounts, shipping rates, validation |
| Webhooks | Real-time events | Order created, product updated, etc. |
| App Bridge | Admin UI integration | Modals, toasts, navigation within admin |
| Flow Actions/Triggers | Automation building blocks | Custom triggers/actions for Shopify Flow |
Custom App vs. Public App: Making the Decision
Custom App -- built for a single store or organization:
- No App Store review required
- Full API access rights (no scoping needed)
- No public listing
- Faster development cycle
- Ideal for: internal tools, ERP integrations, store-specific features
Public App -- published in the App Store:
- Goes through Shopify's review process (4-7 business days initially, approximately 2 weeks total)
- Must comply with Shopify's guidelines (performance, security, UX)
- Billed through Shopify's Billing API
- Reach: potentially all Shopify merchants
- Ideal for: SaaS products, scalable solutions
The Development Process: How an App Project Unfolds
Phase 1: Discovery (1-2 Weeks)
The most important phase -- and the one most often cut short. Here is what happens:
- Problem Definition: What exactly should the app solve? (Not: what should it do -- there is a difference)
- User Stories: Who uses the app and what does that person want to achieve?
- Technical Analysis: Which APIs do we need? Are there limitations?
- Integration Mapping: Which external systems need to be connected?
- Scope Definition: What is MVP, what is Phase 2?
Practical Tip: Invest an extra week in this phase rather than one less. Every ambiguity left unresolved here will cost 5-10x more during development.
Phase 2: Architecture and Design (1-2 Weeks)
- Technical Architecture: Data model, API design, infrastructure
- UI/UX Design: Following Shopify Polaris guidelines (for admin interfaces)
- Prototyping: Clickable prototypes for feedback
- Security Concept: How is data protected? What permissions does the app need?
Phase 3: Development (4-12 Weeks)
This is where the app takes shape. Typically in 2-week sprints:
- Sprint 1-2: Core functionality, API integration, data model
- Sprint 3-4: UI, business logic, initial integration tests
- Sprint 5-6: Edge cases, performance optimization, error handling
- Ongoing: Code reviews, automated tests, staging deployments
Phase 4: Testing and Review (1-3 Weeks)
- Functional Tests: Run through all user stories
- Performance Tests: Lighthouse scores, API response times
- Security Audit: Especially for apps that handle customer data
- Compatibility: Different Shopify plans, browsers, screen sizes
- App Store Review (for public apps): Shopify evaluates performance, security, UX, and billing
Phase 5: Launch and Iteration
- Deployment and monitoring
- Shopify updates APIs regularly -- you need to keep pace
- Prioritize feature requests from users
- Performance monitoring and optimization
Realistic Costs and Timelines
Here are the honest numbers, based on market data and real-world experience:
Development Costs by Complexity
| Complexity | Description | Timeline | Cost |
|---|---|---|---|
| Simple | Dashboard widget, basic automation, single-feature app | 4-8 weeks | 5,000-15,000 EUR |
| Medium | Tracking app, customer portal, multi-feature with 1-2 integrations | 8-12 weeks | 15,000-25,000 EUR |
| Complex | Multi-integration, AI features, custom checkout extensions | 12-20 weeks | 25,000-50,000 EUR |
| Enterprise | AI/ML features, complex ERP integration, high scalability | 6+ months | 60,000-150,000 EUR |
What Drives Costs
API integrations are the biggest cost driver. Every external API (ERP, CRM, logistics, payment provider) comes with its own documentation, authentication, error handling, and edge cases. A SAP integration alone can consume 4-8 weeks of development time.
Scalability makes a huge difference. An app built for a single store is fundamentally different in architecture from one that needs to serve 10,000 stores simultaneously. Database design, caching, queue management, multi-tenancy -- all of that takes development time.
Shopify-specific compliance for public apps: Shopify's review guidelines are strict. Performance is evaluated based on Lighthouse scores. Billing must go through Shopify's own API. This requires experience with the ecosystem.
Ongoing Costs
App maintenance typically runs 15-20% of initial development costs per year. For a 50,000 EUR app, that means 7,500-10,000 EUR annually for:
- Keeping up with Shopify API updates
- Security patches
- Bug fixes
- Performance monitoring
- Infrastructure costs (hosting, database)
The Economics of Public Apps
For developers looking to bring a public app to the App Store, here is the economic reality:
- Average annual revenue per app developer: 93,000 EUR
- Median: Only 8,700 EUR/year -- the distribution is extremely skewed
- The top 0.18% of developers earn over 1 million euros annually
- Currently, 7,874 Shopify Partners have at least one app in the Store
The takeaway: the App Store is not a quick path to profit. It is a competitive market where a handful of apps capture the majority of revenue. Anyone building a public app needs a clear niche advantage and a marketing strategy.
What to Look for in a Development Partner
The Critical Factors
1. Shopify-specific experience: A good React developer is not automatically a good Shopify app developer. Shopify has its own patterns, its own APIs, its own deployment workflows, and its own review guidelines. Ask for concrete Shopify app projects they have completed.
2. GraphQL proficiency: As of April 2025, GraphQL is mandatory. If your development partner still works primarily with REST, that is a red flag.
3. Understanding of the billing system: Shopify has its own rules for app billing. Public apps must bill through the Shopify Billing API. This sounds trivial, but it has pitfalls (usage-based billing, free trials, plan upgrades).
4. Post-launch support: Ask what support looks like after launch. SLAs, response times, update cycles. An app without maintenance is an app on its way to obsolescence.
5. Transparent process: Regular demos, clear milestones, traceable time tracking. If a development partner is not willing to be transparent about their process, that is a problem.
The Most Important Takeaway
The biggest risk in Shopify app development is not technical failure -- it is scope creep. Apps that start as a "small tool" and then accumulate more and more features until budget and timeline are blown.
Define a clear MVP. Build it. Test it with real users. Then expand based on feedback -- not assumptions. The best apps solve a single problem excellently, rather than ten problems mediocrely.