If you browse the Shopify App Store and look at how most apps are built, you'll find a common pattern: Node.js backend, React frontend, hosted on Heroku or Fly.io. It's the default stack that Shopify's own CLI scaffolds out of the box. Remix templates, Polaris components, Express servers — it's all JavaScript, all the way down.

I went a completely different direction. Every Shopify app I build runs on .NET 8 with C#, backed by SQL Server, deployed through Azure DevOps CI/CD pipelines. And after building multiple production apps this way, I'm more convinced than ever that it's the right choice.

Here's why.

The Case Against "Just Use Node.js"

Don't get me wrong — Node.js is a perfectly capable runtime. But the reason most Shopify apps use it isn't because it's the best tool for the job. It's because Shopify's official templates default to it. When you run shopify app init, you get a Remix app. That's not a technical recommendation — it's a starting point.

The problems with the default Node.js approach for Shopify app development start showing up as your app grows:

  • Type safety is optional. TypeScript helps, but it's still bolted on. C# is strongly typed from the ground up — the compiler catches entire categories of bugs before your code ever runs.
  • Dependency sprawl. A typical Node.js Shopify app pulls in hundreds of npm packages. Each one is a potential security vulnerability, a breaking change waiting to happen, or an abandoned project. The node_modules folder for a basic Shopify app can exceed 200MB.
  • No built-in structure. Express gives you a web server and nothing else. You're responsible for building your own architecture — dependency injection, middleware pipeline, data access patterns, configuration management. .NET gives you all of this out of the box.
  • Callback complexity. While async/await has improved things, error handling in deeply nested asynchronous Node.js code is still more fragile than the equivalent C# implementation with proper exception handling and middleware.

Why .NET 8 Is a Better Fit for Shopify Apps

Performance That Matters at Scale

.NET 8 is one of the fastest web frameworks available — consistently outperforming Node.js in TechEmpower benchmarks for both plaintext and JSON serialisation. For a Shopify app handling webhook payloads, processing bulk product updates, or running AI analysis across an entire catalogue, that raw performance translates directly into faster response times and lower hosting costs.

When Intellify — my AI-powered product intelligence app — scans a merchant's catalogue of 500+ products, it needs to process each one, call the Claude API, store results, and return suggestions. The difference between a 200ms and a 50ms per-request overhead compounds fast at that scale.

Enterprise-Grade Architecture from Day One

.NET's built-in dependency injection, middleware pipeline, configuration system, and logging framework mean you start with a production-ready architecture, not a proof of concept that needs to be rewritten later.

My Shopify apps use an N-tier architecture:

  • Presentation layer — MVC controllers handling Shopify OAuth, webhooks, and the embedded admin UI
  • Business logic layer — services containing the app's core functionality, completely decoupled from Shopify's API
  • Data access layer — Entity Framework Core with SQL Server, repositories, and proper migration management
  • Shared models — DTOs and domain models used across all layers

This separation means I can test business logic without needing a Shopify store, swap data providers without touching the UI, and reason about each layer independently.

Entity Framework Core and SQL Server

Entity Framework Core with SQL Server gives me a battle-tested ORM with LINQ queries, automatic migrations, and a relational database that handles complex data relationships properly. Compare that to the typical Node.js Shopify app using Prisma with SQLite or a flat-file session storage — it's a different league.

When SmartTrade Pro needs to calculate tiered trade discounts based on customer tags, order history, and spending thresholds, those queries run against properly indexed SQL Server tables with foreign key relationships. Not JSON files. Not key-value stores. Real relational data with referential integrity.

CI/CD That Just Works

Every app deploys through an Azure DevOps YAML pipeline. Push to the repo, the pipeline builds, runs migrations, and deploys to the production server automatically. No manual FTP uploads, no SSH-and-pray deployments, no remembering to run database migrations by hand.

The pipeline for a typical Shopify app looks like this:

  1. Build — restore packages, compile the solution, catch any build errors
  2. Migrate — apply any pending Entity Framework migrations to the production database
  3. Deploy — publish to IIS on the production server

The entire process takes under two minutes. Push code, grab a coffee, it's live.

Handling Shopify-Specific Concerns in .NET

OAuth and Session Management

Shopify's OAuth flow — the install/authenticate handshake that every embedded app needs — works identically regardless of your backend language. It's HTTP redirects, query parameters, and HMAC validation. C# handles this with clean controller actions, middleware for HMAC verification, and Entity Framework for storing shop tokens.

Webhook Processing

Shopify webhooks are just HTTP POST requests with JSON payloads and HMAC headers. .NET's model binding deserialises them automatically, and the middleware pipeline handles HMAC verification before the request hits your controller. Background processing with IHostedService or a proper queue means webhook handlers return 200 immediately while the heavy work happens asynchronously.

Admin API Integration

Shopify's Admin API (both REST and GraphQL) is HTTP-based. C#'s HttpClient with typed request/response models makes API calls clean, testable, and type-safe. No guessing what shape the response will be — the model defines it explicitly.

Shopify Functions

The one area where .NET doesn't play is Shopify Functions — these run on Shopify's infrastructure and require JavaScript or Rust. For apps like SmartTrade Pro that use discount functions, the function itself is a small JavaScript module, but all the configuration, management, and business logic still lives in the .NET backend.

The Real Advantage: Long-Term Maintainability

The strongest argument for .NET in Shopify app development isn't performance or architecture — it's maintainability. C# code written two years ago still compiles, still makes sense, and still works. The framework doesn't reinvent itself every six months. Microsoft's backward compatibility commitment means your .NET 8 app will have a clear upgrade path to .NET 10, .NET 12, and beyond.

Compare that to the JavaScript ecosystem where frameworks, bundlers, and package managers change constantly. The Shopify CLI itself has gone through multiple major versions with breaking changes. Your Node.js app from 2023 might not even build today without significant dependency updates.

When you're a solo developer maintaining multiple production Shopify apps, that stability isn't a nice-to-have — it's essential.

When Node.js Is Still the Right Choice

I'm not saying Node.js is always wrong for Shopify development. If you're building a simple app with minimal backend logic — maybe a theme customiser or a basic metafield editor — the speed of scaffolding with Shopify's CLI templates is hard to beat. If your team already knows JavaScript and doesn't know C#, the learning curve matters.

But if you're building something substantial — an app that processes data, integrates with external APIs, manages complex business logic, or needs to scale reliably — .NET 8 is worth the investment. The code is cleaner, the architecture is stronger, the performance is better, and the long-term maintenance burden is dramatically lower.

The Bottom Line

Shopify's ecosystem is overwhelmingly JavaScript-based, but that doesn't mean it's the only option — or the best one. .NET 8 with C# gives you type safety, superior performance, enterprise architecture, and long-term stability that the default Node.js stack simply can't match.

Every Shopify app I've shipped — Intellify, SmartTrade Pro, and the ones in development — runs on .NET 8. They deploy through automated pipelines, store data in SQL Server, and handle Shopify's OAuth, webhooks, and APIs with clean, strongly-typed code.

If you're considering building a Shopify app and you have .NET experience, don't let the ecosystem default push you toward Node.js. Build with what's best for your app, not what's in the template.

All Posts View My Apps