The Merchant Engine Hire Badii

// Open-source Shopify alternative, self-hosted

One engine.
Every store
you ship.

An API, an admin, a storefront and an installer, in one MIT repository. French, English and Arabic, cash on delivery, money from config. Clone the repo, run one setup command, then hand the admin to the owner.

./setup.sh --local

Free and open source under MIT. Want it built and run for you? Hire Badii Studio.

The Merchant Engine on Product Hunt

  • 33API modules
  • 7 minfirst local install
  • 26 sre-run

// What you get

Four parts. One install.

01

The API

A NestJS REST API on PostgreSQL and Redis: catalog, cart, checkout, orders, inventory, payments, promotions, gift cards, reviews, returns, shipping, notifications, SEO, analytics, RBAC and an audit log, in 33 modules behind one public config endpoint.

$ curl -s http://localhost:53000/api/v1/store/config
{ "data": { "identity": { … }, "brand": { … },
  "localization": { "supportedLocales": ["en","fr"],
                    "defaultLocale": "en", "rtlLocales": [] },
  "money": { "currencyCode": "EUR", "displayPrecision": 2 } } }
02

The admin

An Angular dashboard for the store owner: orders, payments, catalog, customers, promotions, gift cards, reviews, returns, analytics, roles, and the settings for identity, brand, locales, money and domains. Dark and light: the frame below follows your own colour scheme.

Admin dashboard, in dark or light mode to match the reader's own scheme: revenue and orders tiles with sparklines, a recent activity feed and quick actions.
03

The storefront

A server-rendered Analog.js storefront: home, catalog, search, cart, checkout and customer accounts, in the locales the store enables, mirrored for Arabic, with sitemaps, structured data and llms.txt served.

Storefront catalog page in English: category chips, a brand and price filter rail, a sort control, and product tiles with prices, a sale badge and wishlist buttons.
04

The installer

A stepper that asks for every store-specific value once, verifies storage, mail and bot protection live, renders the stack, builds the images on the box, seeds the store and the owner, issues TLS and probes the result. Idempotent and resumable: an update is a re-run on a newer tag.

$ ./setup.sh --profile both
# or, on a laptop:
$ ./setup.sh --local
> .\setup.ps1

// By the numbers

Checkable, not claimed.

33API modules
3locales, Arabic mirrored
7 minfirst local install
0license keys, tiers or telemetry
Storefront product page in English: gallery, name, rating, reference, a price in euros with the tax mention, stock state, quantity, add to cart and wishlist buttons.
Same engine, left to right.
The same storefront product page in Arabic: the layout mirrored right to left, an Arabic font kit, and a price in dirhams with the symbol before the number.
Same engine, right to left.

// Install

Box to first order in three steps.

  1. Prepare

    A Linux box with Docker, Compose v2, git and Node 22. DNS for the store, the admin and the API. A bucket, a Resend domain and a Turnstile widget.

    Requirements
  2. Install

    Clone the repo, then run one setup command on each server. The stepper verifies each integration live, so a wrong key stops the install rather than the first order. Nothing answers on a public port before the owner account exists.

    Install on a server
  3. Hand off

    The owner signs in, sets the brand, the locales and the money, adds the first product in two locales and places a cash-on-delivery test order. Nightly dumps and certificate renewal are timers, already installed.

    The first hour
setup.ps1 · local profile · real transcript
themerchantengine setup v1.0.1

[1/13] Profile and box role

[2/13] Store identity

[3/13] Domains
  local profile: http://localhost:53300, http://localhost:53200, http://localhost:53000

[4/13] Brand

[5/13] Locales and timezone

[6/13] Currency, tax and shipping

[7/13] Asset storage
  local profile: assets are written to ./uploads on this machine

[8/13] Transactional mail
  local profile: console transport, nothing leaves this machine

[9/13] Sign-up bot protection (Turnstile)
  local profile: sign-up runs without a captcha

[10/13] Payment methods

[11/13] Admin owner account

[12/13] Demo catalogue

[13/13] Summary and confirm
  profile: local
  store: Demo Store (demo), FR
  domains: http://localhost:53300 | http://localhost:53200 | http://localhost:53000
  brand: #1F4E79 + #F2B441, latin-rounded
  locales: en, fr (default en), Europe/Paris
  money: EUR € after, 2 decimals, VAT 20% TTC, shipping 7
  storage: local
  mail: console from Demo Store <noreply@localhost>, redirected to owner@demo.example
  turnstile: off
  payments: cod, manual
  owner: Demo Owner <owner@demo.example>
  demo catalogue: yes

[1/8] Write the environment, the store config and the rendered stack
  ok  deploy/local/docker-compose.yml and deploy/local/.env written

[2/8] Build the images from source

[3/8] Start Postgres and Redis, create the app role and database

[4/8] Push the schema, the search index and the extra indexes

[5/8] Seed the store config, roles, templates, tax, shipping and payment methods

[6/8] Create the admin owner account

[7/8] Start the whole stack

[8/8] Smoke: health, the public config and the front doors
  ok  the API health: http://localhost:53000/health
  ok  the public store config: http://localhost:53000/api/v1/store/config
  ok  the admin login page with its security headers: http://localhost:53200/
  ok  the storefront: http://localhost:53300/

backend server installed successfully!
admin: http://localhost:53200/
owner login: owner@demo.example

storefront server installed successfully!
storefront: http://localhost:53300/
A real run of the installer on a laptop, trimmed to the step lines. The server transcript replaces it after the first fresh-box rehearsal.

// Integrations, live in v1

  • Cash on delivery
  • Stripe
  • Gift cards
  • Manual transfer
  • Resend
  • Turnstile
  • Search Console
  • IndexNow
  • llms.txt
  • S3 storage
  • Zone shipping

Card payment goes through Stripe, embedded or on a hosted page. More card providers plug in behind one interface.

// Hire Badii

Free to use. Hire me to run it.

The engine costs nothing. If you would rather not run it yourself, I install, customize, host and maintain stores built on it, so you can hand over the whole tech side.

Launch

Your store installed on your box or mine, branded, in your locales and currency, with the first catalogue in and a test order through.

Build

Custom work on top: a storefront of your own design, a payment or shipping provider, an integration or a feature the engine does not have yet.

Care

Hosting, updates, backups, certificates and monitoring, with one named person to call when something breaks.

“I built this engine after shipping the same hard parts store after store. It is the code I wanted on every client project, and it is yours under MIT.”

Badii Boutar, Badii Studio
  • 10+client stores shipped
  • 85K+Peeps installs
  • #1livestock marketplace in KSA
  • Use it for any number of client stores, paid or not.
  • No fee, no license key, no license server.
  • Keep the copyright notice. That is the whole deal: read the LICENSE.

// FAQ

Questions, answered.

What stack is The Merchant Engine built on?

A typed TypeScript stack: a NestJS API on PostgreSQL and Redis with Prisma, an Angular admin dashboard, and a server-rendered Analog.js storefront, installed together as a self-hosted ecommerce platform. The API is a REST surface, so a storefront in React, Vue, Svelte or anything else builds on the same endpoints: headless commerce when you want it, a finished storefront when you do not.

What do I need before installing?

For a server: a Linux box with Docker Engine and Compose v2, git and Node.js 22, DNS for the store, the admin and the API, an S3-compatible bucket, a Resend account with a verified domain, and a Cloudflare Turnstile widget. For a laptop: Docker Desktop, git and Node.js 22, nothing else. The full requirements.

Does it run on Windows?

The local profile does, through setup.ps1 on Docker Desktop. A server install runs setup.sh on a Linux box, because that is where the certificates and the timers live.

Is this just another no-code template?

No. It is a stack you install and build on: an API, an admin and a storefront with their source, not a page builder. You keep the code and change what you need.

Do I have to build a storefront, or is one included?

One is included: a server-rendered storefront with home, catalog, search, cart, checkout and customer accounts in French, English and Arabic with a mirrored layout for Arabic. Brand it from the admin and launch, or treat it as the reference implementation and build your own on the same REST API.

Which languages and currencies does it support?

French, English and Arabic: a store enables any pair or all three and picks a default, and the storefront mirrors its layout for Arabic. Any currency, with the symbol, its position, the separators and zero to three decimals set at install and served to every app from the store config.

Which payment and shipping providers are supported?

Cash on delivery, manual transfer, gift cards and card payment through Stripe are live, on an idempotent payment flow with webhook dedup. Stripe card payment is embedded in the checkout or on a hosted page, and the operator enters the keys in the admin. More card providers plug in behind one interface. Shipping is zone-based rates with carrier and tracking management.

Can't I just vibe-code this with AI?

You can get a checkout working with AI in an afternoon. The hard part comes after: race conditions on inventory, idempotent orders and payments, refunds and returns, webhook retries, access control and the security holes you only find once a store takes real money. The Merchant Engine is that part, already built, with the tests that prove it.

Do I keep control of the code, or is this a black box?

You get the source. The engine is open source under the MIT license, and the code runs on your box with no telemetry and no license server.

Can I use it on client projects and bill for it?

Yes. MIT allows any number of client stores, paid or not, with no fee and no license key. Install it once per client and bill for your work.

Is there telemetry?

No. Nothing on the box calls home.

It's v1. How stable is it really?

Every push runs the unit suites, the end-to-end suites against a real database, the lint, the production builds and an install smoke that runs the real installer twice on a fresh box. The counts on this page are read from the release, not typed.

How much does it cost?

Nothing. The engine is free under MIT. You pay only for your own hosting and the third-party services the store uses. If you want it built and run for you, hire Badii Studio.

Can someone build and run it for me?

Yes. Badii Boutar, who builds the engine, works as Badii Studio. He installs, customizes, hosts and maintains stores built on it, so you can hand over the whole tech side. Start at badii.studio/themerchantengine.

Who's building this, and why should I trust it?

Badii Boutar, a full-stack developer with three years of ecommerce work: ten or more client stores shipped, the number one livestock marketplace in Saudi Arabia, and Peeps at 85K+ installs. The engine is built in public and every claim on this page points at the code that proves it.

// Get started

Clone, run setup. Then hand over the admin.

$ git clone https://github.com/Xdabier/themerchantengine.git
$ cd themerchantengine
$ ./setup.sh --profile both