How to Build a Shopify App as a Solo Developer

Step-by-step guide to building a Shopify app by yourself. Tech stack, timeline, costs, and practical advice.

What You're Building

A Shopify app that extends the functionality of Shopify stores. This could be anything from a product review widget to an inventory management tool to a custom checkout upsell system. Shopify has over 4 million active stores, and merchants actively pay for apps that help them sell more or run their stores more efficiently.

Here's what makes Shopify apps compelling as a solo developer project: the merchants are already spending money. They're running businesses. They expect to pay for tools that work. This is fundamentally different from building a consumer app where users resist paying $2.99 for anything.

I started looking into Shopify app development after watching a solo developer share that his simple shipping calculator app was bringing in $8k/month. That number stuck with me. The e-commerce tool market is one of the few places where solo developers can build genuinely profitable products.

Difficulty & Timeline

Aspect	Detail
Difficulty	Medium
Time to MVP	4-8 weeks
Ongoing Maintenance	Medium to High
Monetization	Monthly subscriptions via Shopify Billing API

Recommended Tech Stack

Shopify provides an official app template using Remix (their preferred framework), and I'd strongly recommend using it. Run npm init @shopify/app@latest (the @shopify/cli package is at version 4.1.0 as of this writing, pulling around 345,000 npm downloads a week) and you get a working app with OAuth, session management, and the Shopify API client pre-configured. The template ships with @shopify/shopify-app-remix (4.2.0) wired in, so the auth and webhook plumbing is already there. Fighting the official tooling is a mistake I've seen too many developers make.

For the frontend embedded in Shopify admin, use Polaris (Shopify's React component library, currently version 13.9.5 with about 205,000 weekly npm downloads) alongside App Bridge React (@shopify/app-bridge-react 4.2.10). Your app UI needs to look native to the Shopify admin, and Polaris handles that automatically. Merchants trust apps that look like they belong there.

For the database, use PostgreSQL with Prisma (now on version 7.8.0, with roughly 11.6 million npm downloads a week, so the tooling is battle-tested). Your app needs to store merchant data, configuration, and potentially product data. SQLite won't cut it here because your app runs on a server that handles multiple merchants simultaneously.

Host on Railway, Render, or a VPS. Shopify apps need a publicly accessible URL with HTTPS. Vercel works too, but background jobs (which you'll probably need) are easier on Railway.

Step-by-Step Plan

Phase 1: Foundation (Week 1-2)

Run the Shopify CLI scaffold, create a development store (free from your Shopify Partner account), and install your app on it. Get the OAuth flow working and verify you can make authenticated API calls.

The Shopify Partner Program is free to join with no monthly fees. Do that first if you haven't already. You get unlimited development stores with Advanced plan functionality for testing, plus access to all the documentation and tools.

Understand the app architecture. Shopify apps have two main surfaces: an embedded admin interface (runs inside the Shopify admin as an iframe) and storefront extensions (run on the merchant's actual store). Most apps start with just the admin interface.

Learn the Shopify Admin API. It's a GraphQL API, and as of April 1, 2025 every new public and custom app must be built exclusively on the GraphQL Admin API. The REST Admin API became a legacy API on October 1, 2024, so do not start a new project on it. You'll use the GraphQL Admin API to read and write products, orders, customers, and other shop data. The GraphQL Explorer in the Partner dashboard is your best friend for testing queries.

Phase 2: Core Features (Week 3-5)

Build the one thing your app does. If it's a product review app, build the review submission form, storage, and display widget. If it's an analytics app, build the data collection and dashboard.

Implement the Shopify Billing API from the start. I know it feels early, but here's why: Shopify requires all paid apps to use their billing system. You can't use Stripe directly. And the billing flow affects your app's architecture because you need to check subscription status on every request. Bolting this on later is painful.

Set up webhooks for the events your app cares about. At minimum, handle app/uninstalled (clean up merchant data) and any data-related webhooks relevant to your app. Shopify's webhook delivery is generally reliable, but implement idempotent handlers because you might receive duplicates.

If your app modifies the storefront, look into Shopify's App Blocks and Theme App Extensions. These let merchants add your app's widgets to their store through the theme editor without touching code. This is a massive UX improvement over the old approach of injecting scripts.

Phase 3: Polish & Launch (Week 6-8)

Shopify's app review process is thorough. They test your app manually, check for security issues, verify the billing flow, and ensure your app follows their guidelines. Common rejection reasons include missing privacy policy, broken OAuth flow, or not handling the app/uninstalled webhook properly.

Prepare your app listing with screenshots, a demo video (huge for conversions), detailed description, and proper categorization. The listing is your sales page. Merchants compare apps side by side, and the one with a clear demo video wins almost every time.

Write documentation for merchants. They're not developers. Explain how to install, configure, and use your app in plain language. Include screenshots of every step. Good documentation dramatically reduces support requests.

Monetization Strategy

Shopify's Billing API supports two models: recurring subscriptions and usage-based charges. Most solo developers go with recurring subscriptions because they're predictable.

Price based on value delivered. If your app helps merchants make more money, price it as a percentage of that value. A $29/month app that reliably increases average order value by 15% is a no-brainer for any store doing $10k+ in revenue.

Common pricing tiers for solo-built Shopify apps: $9.99/month for basic, $29.99/month for pro, $79.99/month for advanced. Offer a 7-14 day free trial. Shopify handles the trial logic through their billing API.

One thing that's unique to Shopify, and it works heavily in your favor as a solo developer just starting out. You pay 0% revenue share on your first $1,000,000 USD of lifetime gross app revenue, then 15% on everything above that threshold. There is a separate 2.9% payment processing fee on all earnings. This means a solo app that has not yet crossed a million dollars in cumulative revenue keeps everything except that 2.9% processing fee. If you charge $29/month, you keep roughly $28 until you cross the lifetime threshold, then about $24 once the 15% share kicks in. Note that earnings before January 1, 2025 do not count toward the $1 million threshold, and the threshold is lifetime rather than annual under the current policy. The distribution is the real win here. Shopify puts your app in front of a platform with millions of store owners.

If your app reaches enough merchants, Shopify might feature it on their homepage or in their recommended apps. That kind of exposure is worth more than any ad spend.

Common Mistakes to Avoid

Not using the Shopify CLI and official templates. Some developers try to build everything from scratch. Don't. Shopify's auth flow, session management, and API client have edge cases that the official tooling handles for you. I watched a developer spend two weeks rebuilding the OAuth flow when @shopify/shopify-api (currently version 13.0.0, about 368,000 npm downloads a week) handles it in a few lines.

Ignoring rate limits. Shopify's API has a leaky bucket rate limit. If your app makes too many API calls (especially during bulk operations), you'll get throttled. Implement proper rate limit handling with retry logic and backoff. This becomes critical when merchants have large catalogs with thousands of products.

Skipping the uninstall cleanup. When a merchant uninstalls your app, you should delete their data (or at least flag it for deletion). Shopify checks for this during review, and GDPR requires it. Handle the app/uninstalled webhook and the mandatory data deletion webhooks.

Building for the wrong merchant size. Small stores (<$1k/month revenue) are price-sensitive and churn fast. Enterprise stores need features you can't build as a solo developer. The sweet spot is mid-market: stores doing $10k-500k/month. They have the budget for apps and enough volume to get value from your tool.

Is This Worth Building?

If you can find a genuine gap in the Shopify App Store, absolutely. The economics are excellent. Shopify merchants pay for tools monthly, churn is relatively low for useful apps, and the platform is growing.

The challenge is competition. There are thousands of apps in the store, and some categories are saturated. But here's the thing: most of those apps are mediocre. They have clunky UIs, poor documentation, and slow support. If you build something clean, fast, and well-supported, you can win even in competitive categories.

Talk to Shopify merchants before you build. Join Shopify communities, Reddit's r/shopify, and Facebook groups. Ask what frustrates them. The best Shopify app ideas come from merchants themselves, not from developers guessing what merchants need. I'd spend a week doing research before writing a single line of code.

Common Errors and Fixes

You scaffolded against the REST Admin API and your new app gets rejected. Since April 1, 2025, all new public and custom apps must be built exclusively on the GraphQL Admin API, and the REST Admin API has been a legacy API since October 1, 2024. If a tutorial or older boilerplate has you calling REST product endpoints, switch to the GraphQL Admin API before you go any further. Use the current npm init @shopify/app@latest template, which is already GraphQL-first.

Throttled errors during bulk reads or writes. Shopify's GraphQL Admin API uses a calculated query-cost rate limit (a leaky bucket per shop), and REST uses a request-based bucket. When you exceed the available points you get throttled responses. The fix is to read the cost extensions returned in each GraphQL response, back off when the available points run low, and retry with exponential backoff. For large catalog operations, use the bulk operation APIs instead of looping over individual calls.

Mandatory compliance webhooks not handled, so review fails. Beyond app/uninstalled, Shopify requires every app that stores customer data to implement the mandatory GDPR compliance webhooks (customers/data_request, customers/redact, and shop/redact). Apps that skip these get rejected in review. Wire them up early and make the handlers idempotent, because Shopify can resend a webhook if it does not receive a 200 response in time.

HMAC verification failing on incoming webhooks. Webhooks must be verified against the raw request body using your app's secret. If you parse the body to JSON before computing the HMAC, the signature will never match and Shopify will treat your endpoint as failing. Verify the HMAC against the unparsed raw body first, then parse.

App loads in the browser but blanks out inside the Shopify admin iframe. Embedded apps must use App Bridge and serve the correct frame-ancestors content security policy header so the admin can embed them. The official Remix template handles this for you. If you bypass it, set the CSP frame-ancestors to the shop and Shopify admin origins, otherwise the iframe is blocked.