Shopify’s platform operates at a scale that challenges even the most robust systems. On Black Friday 2024 alone, Shopify processed 173 billion requests, peaked at 284 million requests per minute, and pushed 12 terabytes of data every minute through its edge infrastructure. These figures are not isolated spikes—they represent the sustained performance targets that Shopify consistently meets. Behind these impressive numbers lies a carefully engineered technology stack, blending simplicity with advanced architectural decisions to ensure speed, resilience, and a seamless developer experience.

Backend Architecture

At its core, Shopify’s backend is built on Ruby on Rails. The original codebase, established in the early 2000s, remains the foundation of the system. Rather than migrating away from Rails, Shopify has invested heavily in enhancing it for longevity and performance. Key innovations include:

• YJIT: A Just-in-Time compiler for Ruby, built with Rust, that boosts runtime performance without altering developer workflows.
• Sorbet: A static type checker for Ruby, co-developed by Shopify, ensuring robust type safety and contract enforcement.
• Rails Engines: Used as modular components, each functioning as a mini-application, these engines allow for code isolation, ownership, and potential extraction.

This approach has resulted in one of the largest and most enduring Rails applications in production.

Modularization Strategy

Shopify employs a modular monolith architecture. The entire codebase exists in a single repository and process, yet it is divided into independently deployable components with strict boundaries. Each component exposes a public interface, enforced by Sorbet, to prevent tight coupling and facilitate safe refactoring.

Components are organized into logical layers:

• Platform: Core services like identity and database abstractions
• Supporting: Business domains such as inventory and shipping
• Frontend-facing: Interfaces like the online store and GraphQL APIs

This structure, supported by static analysis tools and comprehensive monitoring, enables teams to work efficiently without losing control over the system’s complexity.

Frontend Technologies

Shopify’s frontend has evolved alongside the web ecosystem. Early iterations used server-rendered HTML with jQuery, then moved to Batman.js for single-page applications. Today, the Shopify Admin interface leverages React, React Router by Remix, and TypeScript, communicating exclusively with the backend via GraphQL. This strict separation of concerns ensures consistency across web and mobile platforms, as both use GraphQL for data access.

Mobile Development with React Native

Shopify’s mobile apps are built with React Native, allowing shared code between Android and iOS. Shared libraries handle common features like authentication and error tracking, while native modules are used for platform-specific functionality. Shopify also contributes to the React Native ecosystem, enhancing tools like Mobile Bridge, Skia, WebGPU, and Reanimated.

Programming Languages and Tooling

Shopify’s technology choices are driven by developer productivity and operational resilience:

• Ruby: The backbone of backend services and the monolith
• Sorbet: For static type checking in Ruby
• TypeScript: Standard for frontend and mobile development
• JavaScript: Used in legacy and shared libraries
• Lua: Powers custom scripting in OpenResty, Shopify’s edge HTTP server
• GraphQL: The preferred API interface for clients
• Kubernetes YAML: Defines infrastructure and deployments
• Remix: Used for full-stack web applications, including Shopify Admin and Hydrogen

Developer Tooling & Open Source Contributions

Shopify maintains a robust ecosystem of internal and open-source tools:

• Packwerk: Enforces dependency boundaries within the monolith
• Tapioca: Automates Sorbet interface file generation
• Bootsnap: Accelerates Ruby application startup
• Maintenance Tasks: Standardizes background job execution
• Toxiproxy: Simulates unreliable network conditions for testing
• TruffleRuby: High-performance Ruby implementation
• Semian: Circuit breaker for critical resources
• Roast: Framework for structured AI workflows

Databases, Caching, and Queuing

Shopify relies on MySQL as its primary database, implementing sharding and later introducing pods—isolated slices of the platform, each with its own MySQL, Redis, and Memcached instances. This pod model eliminates single points of failure and enables horizontal scaling.

• Memcached: Handles key-value caching for fast data retrieval.
• Redis: Powers background job queues and asynchronous workflows. After a major outage known as “Redismageddon,” Redis was restructured to match the pod model, localizing failures and improving reliability.

Messaging and Service Communication

• Kafka: Serves as the backbone for messaging and event streaming, handling up to 66 million messages per second. Kafka decouples producers from consumers, supporting real-time analytics, search, and business workflows.
• REST & GraphQL APIs: REST is used for legacy internal communication, while GraphQL is the standard for frontend and mobile clients. Shopify is also exploring RPC and service mesh architectures to standardize and strengthen service-to-service communication.

Machine Learning Infrastructure

Shopify’s ML infrastructure is built on two pillars:

• Real-Time Search with Embeddings: Semantic search uses text and image embeddings for contextual results. The system processes over 216 million embeddings daily, optimizing memory and GPU usage through deduplication.
• Data Pipeline Infrastructure: ML pipelines run on Apache Beam via Google Cloud Dataflow, supporting streaming inference, GPU acceleration, and efficient parallelism. Embeddings are stored in BigQuery for analytics.

DevOps, CI/CD & Deployment

• Kubernetes: Shopify deploys infrastructure using Kubernetes on Google Kubernetes Engine, with each pod defined via YAML.
• Docker & OpenResty: Applications are packaged in Docker containers, and edge traffic is managed with OpenResty and Lua scripting.
• Buildkite: Orchestrates continuous integration, running hundreds of thousands of unit tests in parallel to ensure rapid feedback.
• ShipIt & Feature Flags: Deployments are controlled through a merge queue, with feature flags enabling rapid rollbacks and controlled feature exposure.

Observability, Reliability, and Security

Shopify’s observability infrastructure is anchored by ServicesDB, an internal registry tracking service ownership, health, and compliance. Incident response is a shared responsibility, with lateral escalation based on domain expertise. Tools like Semian and Toxiproxy bolster fault tolerance and resilience.

Security is a core focus, with ongoing investments in the Ruby ecosystem, partnerships with Ruby Central, and funding for academic research to enhance package security and performance.

Shopify’s Scale in Numbers

• $5 billion GMV processed on Black Friday
• 284 million requests per minute at peak
• 173 billion requests in a single day
• 12 TB/minute edge network traffic
• 45 million database queries per second (reads)
• 7.6 million database writes per second
• 66 million Kafka messages per second
• 100,000+ unit tests per monolith build
• 216 million ML embeddings processed daily
• 99.9% crash-free React Native sessions
• 2.8 million lines of Ruby code in the monolith
• 100+ isolated pods and 100+ internal Rails apps

Conclusion

Shopify’s technology stack is a masterclass in balancing simplicity with scale. Through deliberate architectural choices, continuous investment in tooling, and a focus on developer experience, Shopify powers one of the world’s most resilient and scalable commerce platforms. This stack not only supports massive transaction volumes and global events but also ensures the platform remains agile, reliable, and secure for millions of businesses worldwide.

Read more such articles from our Newsletter here.