Medusa.js does not manage your hosting. That is the tradeoff for owning your infrastructure. You get a production stack that is entirely under your control — and you are responsible for keeping it running.
Here is what the infrastructure stack looks like, what it costs at each scale tier, and how that compares to Shopify’s flat monthly fee.
What Medusa Requires to Run
A production Medusa deployment needs four core services running together:
1. Node.js application server — the Medusa backend API itself. Medusa v2 requires Node.js 20+. It runs as a standard Node.js process — deployable anywhere that can run a Node.js app.
2. PostgreSQL — the primary database. Medusa stores products, orders, customers, inventory, and all application state in PostgreSQL. This needs to be a managed database with regular backups and point-in-time recovery.
3. Redis — used for queue management (background jobs, event handling) and session caching. Medusa’s workflow engine relies on Redis for job scheduling and retry logic.
4. File storage — for product images, media, and uploads. Medusa supports local file storage (not suitable for production), S3-compatible storage (AWS S3, DigitalOcean Spaces, Cloudflare R2), and other providers via plugins.
A fifth service — a CDN — is not required but effectively mandatory for any store serving customers across geographic regions.
Your frontend (typically a Next.js storefront) deploys separately from the Medusa backend. Vercel is the standard choice for Next.js frontends.
Hosting Options by Platform
Railway
Railway is the most popular choice for Medusa deployments in 2025–2026. It deploys Node.js services, PostgreSQL, and Redis from a single dashboard with minimal configuration.
A standard production Medusa setup on Railway:
- Medusa service (Starter tier): $20–$40/month
- PostgreSQL (managed): $25–$50/month
- Redis: $10–$20/month
- Total: $55–$110/month
Railway’s pricing is usage-based, so low-traffic stores pay less and high-traffic stores pay more. The Railway dashboard makes scaling services vertically straightforward — no infrastructure expertise required.
The main limitation: Railway does not have enterprise-grade SLAs. It’s an excellent choice for stores under $2M GMV but may not satisfy procurement requirements at larger enterprises.
Render
Render is comparable to Railway in simplicity, with slightly different pricing tiers. A Medusa production setup on Render:
- Web Service (Standard): $25–$85/month
- PostgreSQL (managed): $20–$85/month
- Redis: $10–$25/month
- Total: $55–$195/month
Render offers auto-deploys from GitHub, preview environments, and a managed zero-downtime deploy process. It is a solid option for teams that want Railway-like simplicity with more deployment pipeline control.
AWS / GCP / Azure
For larger deployments or businesses with compliance requirements, running Medusa on major cloud infrastructure provides more control and higher SLA guarantees.
A production Medusa stack on AWS:
- EC2 (t3.medium for Medusa API): $30–$60/month
- RDS PostgreSQL (db.t3.medium, Multi-AZ): $60–$120/month
- ElastiCache Redis (cache.t3.micro): $15–$30/month
- S3 for file storage: $5–$20/month
- CloudFront CDN: $5–$30/month
- Application Load Balancer: $20–$25/month
- Total: $135–$285/month
At high traffic (50,000+ orders/month), you scale the EC2 instances, add read replicas to the database, and potentially move to ECS or EKS for container orchestration. At that scale, AWS monthly costs reach $500–$2,000+.
DigitalOcean App Platform
DigitalOcean’s App Platform supports Node.js with managed databases and is popular for its straightforward pricing and developer-friendly interface.
A Medusa setup on DigitalOcean:
- App Platform (Basic): $12–$50/month for the Medusa service
- Managed PostgreSQL: $15–$60/month
- Managed Redis: $15–$30/month
- Spaces (S3-compatible storage): $5/month + bandwidth
- Total: $47–$145/month
Storefront Hosting (Frontend)
The Next.js storefront typically deploys separately on Vercel.
- Vercel Hobby (personal projects, no commercial SLA): Free
- Vercel Pro: $20/month per seat
- Vercel’s serverless functions and edge network are well-optimized for Next.js — this is the standard choice for most Medusa storefronts
For high-traffic stores, Vercel’s usage-based pricing can reach $200–$500/month for the frontend alone. At that scale, self-hosting the Next.js app on the same cloud infrastructure as the Medusa API becomes cost-effective.
What a Real Production Stack Looks Like
A production Medusa deployment for a store doing $1M–$3M GMV typically looks like this:
| Service | Provider | Monthly Cost |
|---|---|---|
| Medusa API | Railway or Render | $40–$80 |
| PostgreSQL | Railway managed or Render managed | $50–$85 |
| Redis | Railway or Render | $20–$25 |
| File storage | Cloudflare R2 (zero egress fees) | $5–$20 |
| CDN | Cloudflare (free tier covers most needs) | $0–$20 |
| Storefront | Vercel Pro | $20–$40 |
| Email service | Resend or Postmark | $10–$30 |
| Total | $145–$300/month |
At this scale, total infrastructure runs $1,740–$3,600/year.
Infrastructure Cost vs Shopify: The Real Comparison
Shopify’s pricing for a store at this scale:
- Shopify Advanced plan: $399/month ($4,788/year)
- Transaction fees (using non-Shopify Payments): 0.5–2% depending on plan
- Apps (a real mid-size Shopify store runs 8–15 paid apps): $150–$600/month additional
- Total: $550–$1,000+/month, or $6,600–$12,000/year
Medusa at $145–$300/month saves $2,400–$10,000/year in operational costs at this GMV level.
The critical difference: Shopify’s fee scales with your revenue and requires ongoing app subscriptions for features that Medusa includes natively or can build once. Medusa’s infrastructure cost scales with usage — not with how much money you make.
For a deeper look at Shopify’s true cost at scale, see our true cost of Shopify at scale breakdown.
DevOps Requirements: What Running Medusa Actually Demands
Medusa’s infrastructure ownership comes with operational responsibility. This is not Shopify’s “it just works” environment. Here’s what running a production Medusa deployment actually requires:
Database management:
- Automated backups (daily minimum, hourly for high-volume stores)
- Monitoring for slow queries and connection pool exhaustion
- Point-in-time recovery capability
Application monitoring:
- Error tracking (Sentry, free tier covers most needs)
- Uptime monitoring (Better Uptime, Pingdom, or UptimeRobot)
- Performance APM for identifying bottlenecks
Security:
- Dependency updates (Node.js ecosystem has frequent security patches)
- Environment variable management (never committed to Git)
- TLS certificate renewal (Render and Railway handle this automatically)
- Database access controls — your Postgres should not be publicly accessible
Deployment pipeline:
- CI/CD for automated testing and deployment (GitHub Actions is free for public repos, $4/month for private repos with reasonable usage)
- Environment separation — staging and production should be separate services, not the same instance
Most of this is handled by choosing a managed platform (Railway, Render, DigitalOcean) rather than bare-metal. On a managed platform, database backups, TLS, and scaling are handled by the provider. The remaining operational overhead for a Medusa store on Railway is 2–4 hours/month for a competent developer.
Scaling Medusa: What Changes as You Grow
At under 1,000 orders/month, a single Medusa instance and a small managed Postgres is sufficient.
At 5,000–10,000 orders/month, you add more memory to the Medusa service, watch for database connection limits, and possibly add read replicas for reporting queries.
At 50,000+ orders/month, horizontal scaling becomes relevant — multiple Medusa instances behind a load balancer, connection pooling via PgBouncer, dedicated Redis clusters. This is the zone where moving to AWS or GCP managed infrastructure starts to make sense.
Medusa’s architecture does not impose horizontal scaling limitations. The backend is stateless (state lives in PostgreSQL and Redis), so adding instances behind a load balancer is straightforward. This is meaningfully different from Magento, where scaling involves significant architectural complexity.
For context on how Medusa’s infrastructure compares at the high end of the market, see our Medusa.js vs Magento 2 comparison.
Worker Services for Background Jobs
Medusa runs background jobs (order notifications, inventory updates, webhook processing) through a Redis-backed worker process. In production, this worker should run as a separate service from the API — if a background job process consumes excessive memory, it shouldn’t bring down your storefront API.
Most managed platforms (Railway, Render) support multiple services in the same project. The Medusa worker is a separate entry point (medusa worker) that deploys alongside the API at an additional $10–$25/month.
Skipping this separation is a common mistake in small Medusa deployments. Running worker and API in a single process works in development and fails unpredictably in production under load.
Cost Summary by Scale
| Store Scale | Monthly Infrastructure | Annual Infrastructure |
|---|---|---|
| Early stage (under $250K GMV) | $60–$110 | $720–$1,320 |
| Growing ($250K–$1M GMV) | $100–$200 | $1,200–$2,400 |
| Mid-market ($1M–$5M GMV) | $150–$400 | $1,800–$4,800 |
| Scale ($5M–$20M GMV) | $400–$1,500 | $4,800–$18,000 |
| Enterprise ($20M+ GMV) | $1,000–$5,000+ | $12,000–$60,000+ |
These figures are infrastructure only. Build costs, ongoing development, and team time are separate.
FAQ
What does it cost to host a Medusa.js store in production?
A production Medusa stack on Railway or Render runs $55–$200/month for the backend (API, PostgreSQL, Redis, file storage). Add $20–$40/month for Vercel hosting of the Next.js storefront. Total infrastructure typically runs $75–$240/month, or $900–$2,880/year.
Does Medusa have managed hosting like Shopify?
No official managed hosting exists yet, though this is on the Medusa roadmap. Some agencies offer hosted Medusa environments as part of their service package. Otherwise, you choose a platform (Railway, Render, DigitalOcean, AWS) and manage the deployment.
Can I run Medusa.js on shared hosting?
No. Medusa requires Node.js 20+, a dedicated PostgreSQL database, and Redis. Shared cPanel/Plesk hosting does not support these. You need VPS or cloud hosting at minimum.
How does Medusa hosting cost compare to Shopify?
Shopify Advanced is $399/month. A comparable Medusa stack runs $75–$200/month in infrastructure. The difference ($200–$300/month) compounds to $2,400–$3,600/year in savings — before accounting for Shopify’s app costs, which add $150–$600/month for most real stores.
What skills are needed to manage Medusa.js hosting?
Basic Node.js deployment knowledge and comfort with a cloud dashboard (Railway, Render, or AWS). Most routine operations on managed platforms (Railway, Render) require no Linux administration. Database management, monitoring setup, and CI/CD configuration require developer-level skills — either in-house or from an agency on retainer.
Can Medusa.js scale to handle Black Friday traffic spikes?
Yes, with proper architecture. Medusa’s stateless API scales horizontally — add instances behind a load balancer. The storefront on Vercel scales automatically. Database connections are the most common bottleneck at spike traffic; PgBouncer connection pooling addresses this. A properly configured Medusa deployment on AWS or GCP can handle 10,000+ concurrent users.
Do I need Redis for Medusa.js?
Yes in production. Redis is required for Medusa’s job queue and event system. Running without Redis means background jobs (email notifications, inventory updates, webhook handling) either don’t run or block the main API process. A managed Redis instance at $10–$25/month is a mandatory production dependency.
If you want to understand what a properly architected Medusa deployment looks like as part of a full build, our fixed-price packages cover what’s included. For businesses that need ecommerce without managing the infrastructure — and whose requirements fit within it — our WooCommerce development services offer a managed-hosting-friendly alternative.