You're paying $79 a month for your Shopify plan, another $19 for the app that handles bundles, $12 for the one that adds a wishlist, and suddenly your "free" store costs more than your first wholesale order did. Sound familiar?
That's the moment a lot of small sellers start Googling "Shopify alternatives" at midnight. And one name keeps coming up: Medusa.js — an open-source, self-hosted commerce engine that you own completely. No per-transaction fees, no app-store tax, no platform telling you which payment processors you're allowed to use.
The catch people assume is that it's only for developers with a computer science degree. It's not. If you can follow a recipe and aren't afraid of a terminal window, you can have a working store this weekend. Let me walk you through exactly how.
What Medusa.js Actually Is (Plain English)
Medusa is a headless commerce backend — meaning it handles all the commerce logic (products, carts, orders, customers, discounts) through an API, and you plug in whatever frontend you want. Think of it like a restaurant kitchen: Medusa is the kitchen, and your storefront is the dining room. They talk to each other, but you can redesign the dining room anytime without touching the stoves.
The project is MIT-licensed, lives on GitHub with over 24,000 stars, and has an active community. You host it yourself — on a $6/month VPS, on Railway, on Render, wherever you like. That's why the monthly cost can drop to nearly zero compared to a $79+ SaaS platform.
Medusa ships with:
- A Node.js backend (the API server)
- An admin dashboard (React app, looks a lot like a cleaner Shopify admin)
- A Next.js storefront starter you can deploy straight to Vercel
You don't have to build anything from scratch. The starter is a real, shoppable storefront — product pages, cart, checkout, order confirmation — out of the box.
What You'll Need Before You Start
Before Saturday morning coffee, make sure you have these four things ready:
- Node.js 18+ installed on your machine. Run
node -vin your terminal to check. If it's missing, grab it from nodejs.org — five-minute install. - A PostgreSQL database. Medusa uses Postgres, not SQLite. The easiest free option for a weekend project is a Neon.tech database (free tier, takes three minutes to spin up, gives you a connection string).
- A Stripe account (free to create). Medusa's default payment plugin uses Stripe. You'll use test mode the whole weekend — no real charges.
- A Vercel account (also free) for deploying the storefront frontend. You can use Netlify too, but Vercel + Next.js is the smoothest pairing.
That's it. Total upfront cash: $0.
Day One: Get the Backend Running Locally
Saturday is for the engine. Here's the sequence:
Step 1 — Scaffold the project. Open your terminal and run:
npx create-medusa-app@latest my-store
The CLI will ask if you want to include the Next.js storefront. Say yes. It installs everything in one shot — backend, admin, and storefront starter — into a folder called my-store. Grab a coffee while it runs; it takes three to five minutes.
Step 2 — Add your database URL.
Inside my-store/backend, you'll find a .env file. Open it and paste your Neon (or other Postgres) connection string into the DATABASE_URL field. It looks like postgresql://user:password@host/dbname.
Step 3 — Run migrations and seed data.
Still inside the backend folder, run:
npx medusa db:migrate
npx medusa db:seed
The seed command loads sample products, a default region, and a test shipping option so you have something to look at immediately.
Step 4 — Start the backend.
npx medusa develop
Your API is now running at http://localhost:9000 and the admin dashboard at http://localhost:9000/app. Create your admin account when prompted — this is your store's control panel.
Spend the rest of Saturday in the admin: upload your real product photos, write your descriptions, set your prices, configure your shipping zones. It genuinely feels like Shopify admin, just without the upsell banners everywhere.
Quick sanity check: add a product, then visit http://localhost:9000/store/products in your browser. You should see your product returned as JSON. If you do, the backend is healthy.
Day Two: Launch the Storefront
Sunday is for the front door — the part customers actually see.
Step 1 — Configure the storefront.
Navigate to my-store/storefront. There's another .env.local file here. You need two values:
NEXT_PUBLIC_MEDUSA_BACKEND_URL— point this at your backend. Locally, that'shttp://localhost:9000.NEXT_PUBLIC_DEFAULT_REGION— use the region handle you set up in the admin (usuallyusfrom the seed data).
Step 2 — Run the storefront locally.
npm run dev
Visit http://localhost:8000. You'll see a real storefront — hero section, product grid, individual product pages with variant selectors, a working cart drawer, and a Stripe-powered checkout flow. All of it functional, none of it mocked.
Do a test purchase end-to-end right now. Use Stripe's test card number (4242 4242 4242 4242, any future expiry, any CVC). Watch the order appear in your admin dashboard. That moment — seeing your own order land in a system you control — is genuinely satisfying.
Step 3 — Deploy to Vercel.
Push your storefront folder to a GitHub repo, then import it into Vercel. Add the same environment variables in Vercel's project settings. Hit deploy. In about two minutes you have a live URL.
For the backend, Railway is the friendliest one-click option. Connect your GitHub repo, point it at the backend folder, add your environment variables, and Railway handles the Node process and keeps it running. Their Starter plan runs about $5 a month — still a fraction of a Shopify subscription.
Customizing Without Breaking Everything
Here's where a lot of first-timers panic: "I need to change the colors and add my logo, but I don't want to wreck the checkout."
Good news — the storefront starter uses Tailwind CSS, which means visual changes are almost always just class name swaps, not structural surgery. Open storefront/src/app/layout.tsx to change fonts and global styles. Open storefront/src/styles/globals.css to update your color palette. Your logo goes in the Nav component, usually at storefront/src/modules/layout/components/nav/index.tsx.
For branding, you realistically need to touch three files:
- The nav component (logo + colors)
- The globals CSS (brand palette)
- The hero section on the home page
That's a Sunday afternoon, not a week-long project.
What about adding features later — a wishlist, product reviews, subscriptions? Medusa has a plugin system and a growing ecosystem. But here's the honest operator's take: get revenue first, then add features. A clean store that converts beats a feature-rich store that launched six months late every single time. I learned that the hard way on my first store, spending three weeks on a loyalty program before I'd made a single sale.
The Real Costs: Honest Numbers
Let's put actual figures on this so you can plan.
| Item | Monthly Cost |
|---|---|
| Neon Postgres (free tier) | $0 |
| Vercel (hobby tier) | $0 |
| Railway backend (Starter) | ~$5 |
| Stripe fees | 2.9% + $0.30 per transaction |
| Custom domain | ~$1.25 (amortized) |
| Total fixed cost | ~$6.25/month |
Compare that to Shopify Basic at $39/month (or $79 on the plan with better reporting), plus apps, plus Shopify Payments' 2.9% + $0.30 — or 0.5–2% extra if you use a third-party processor.
At $10,000/month in sales, the difference in fixed platform costs alone is $33–73/month back in your pocket. Not life-changing on its own, but it compounds, and you own the infrastructure.
The real cost of Medusa is your time — maybe 8–12 hours to set up, and ongoing time when you want to add something custom. If your time is genuinely worth more than that, a hosted platform might still be the right call. No shame in that. But if you're technical-curious and want to stop renting your store, this weekend project pays for itself fast.
You Can Do This
A working Medusa storefront is two focused days of work. Saturday: backend up, products loaded, admin configured. Sunday: storefront live, test order placed, deployed to the world.
You don't need to be a full-stack developer. You need to be comfortable reading error messages, copying environment variables carefully, and not giving up when something doesn't work on the first try — which, honestly, describes every successful store owner I've ever met.
Here's your next step: go spin up that free Neon database right now, before you close this tab. It takes three minutes, and having it ready means Saturday morning you start building instead of doing setup. The create-medusa-app command will do the rest.
Your store, your stack, your rules.