Skelet
GitHubGet started
Menu

Self-hosted ecommerce

Pre-1.0

Commerce you run yourself

Skelet is a self-hosted ecommerce platform: a Go GraphQL backend, a React admin and Next.js storefronts, all in containers. Several shops from one back office, analytics built in, and extensions that stay yours.

Get startedStar on GitHub

The stack

Backend
Go 1.27
Database
Postgres 18
API
GraphQL
admin and storefront
Admin
React
Storefronts
Next.js
Analytics
Signals
on its own database

Open source

GPL-3.0

Get started

Docker is all it needs

Clone it and get going

No stitching together ten services to sell your first product. Docker is all it takes - the Go and Node toolchains run in containers too, so there's nothing else to install.

Every command, in detail

Terminal
  1. 01gitclonegit@github.com:skeletg/skelet.git&&cdskelet
  2. 02./skeletsetup# pick apps, write env, migrate
  3. 03./skeletup# backend, your apps, sidecars
  4. 04./skeletcliadmincreate-superuser# your first login
./skelet on its own lists every command, and ./skelet help <command> explains one.

The admin

Sample data

0:00
0:00

Commerce

One Go backend

Everything a shop needs, in one backend

See everything it does

  • Catalog

    Simple, configurable, bundle, kit and grouped products, attributes, collections and categories.

    • Variants driven by attributes or by a list
    • Bundles priced as a bundle, per channel
    • Filter order set per category and collection
    • Per-channel URLs, with redirects that follow renames

  • Configurator

    Options and choices with pictures, rules that change price or quantity, templates shared across products, a step-by-step picker.

    • Text, choice, date and file options
    • Conditions that show an option only for certain answers
    • Rules that make an option required, or set its quantity or price
    • Templates handed to a whole product type

  • Carts and checkout

    Delivery options, store pickup, PO boxes, and offers an admin builds and sends as a link.

    • Guest carts merged into the account at sign-in
    • Delivery limited and priced per product type
    • Tax by channel, prices shown with or without it
    • Offers with locked prices and an expiry

  • Orders and payments

    Partial fulfilment, refunds with credit memos, offline methods, and card gateways as plugins.

    • A payment ledger: authorize at checkout, capture at fulfilment
    • Credit memos numbered for every refund
    • Draft and manual orders, and a cart console for admins
    • Cash on delivery, bank transfer, pickup and purchase order built in

  • Promotions and loyalty

    Conditions and actions, coupons, gift cards, loyalty and referrals.

    • Nested conditions, priorities, stacking and usage limits
    • Coupon batches, with overrides per code
    • Gift cards that pay like a tender, not a discount
    • Points and referrals paid out as store credit

  • Subscriptions

    Recurring products with their own invoice ledger.

    • Billed every so many days, weeks, months or years
    • Terms fixed at purchase, so later edits to the product leave them be
    • Pause and resume, and time paused is never billed
    • Failed renewal charges retried on a schedule

  • Inventory

    Multiple locations, reservations and per-store stock.

    • Stock levels per location
    • Reservations from checkout to fulfilment, kept apart from what is on the shelf
    • A stock ledger that explains every change
    • Back-in-stock alerts for shoppers

  • Content

    A block-based CMS, a blog, a media library, and SEO tools that crawl your own site.

    • Blocks scheduled, and shown to the audiences you pick
    • A blog with authors, categories and tags
    • Media on S3-compatible storage or the filesystem
    • Navigation menus and forms built in the admin

Signals

Optional

Analytics that live with your store

Signals is a built-in analytics suite with its own database. Your data stays on your servers, and it already knows what a product, an order and a customer are.

0:00
0:00

It's optional. Switch it off and the commerce core runs alone. Explore Signals

Developers

Plugins, webhooks, two APIs

Built for the people who build on it

Two GraphQL endpoints, admin and storefront, with separate schemas - storefront introspection can't see an admin operation. Resolvers, the data layer and the frontends' types are all generated from schemas, and a check fails when they drift.

  • Go plugins compiled into the binary, against a versioned SDK
  • Remote providers in any language, over signed HTTP
  • HMAC-signed webhooks, sync and async
  • Integration tokens for machine access
  • A transactional outbox and a scheduled-jobs engine

How to extend Skelet

Go
func init() {
    p := sdk.RegisterPlugin(sdk.Manifest{
        Slug:     "my-carrier",
        Name:     "My Carrier",
        Version:  "0.1.0",
        SDKRange: "^0.1.0",
    })
    p.RegisterShippingCarrier("standard", &carrier{},
        sdk.WithCarrierDisplayName("Standard"))
    p.RegisterRoute("GET ping", pingHandler)
}
A shipping carrier plugin, registered from init().

License

GPL-3.0 with a plugin exception

Your code stays yours

Skelet is GPL-3.0, so Skelet itself stays open and a fork can't go closed. Plugins, remote providers, storefronts, dashboard extensions and themes are exempt: license them however you like, closed included.

  • Run it, host it and change it, free
  • Build client sites on it and charge for them
  • Keep your extensions private

The license in plain words

Architecture

One backend, two APIs

How it fits together

One Go backend serves two GraphQL APIs - one for the admin, one for every storefront - over Postgres. Signals, the analytics suite, runs beside it on databases of its own, and switches off cleanly.

The architecture in depth

  • Two APIs, one backend

    The admin and the storefronts share a process but not a schema. Each endpoint has its own, so a storefront can't even see what the admin can do.

  • Signals is optional

    Switch it off and the commerce core runs alone. Switched on, it talks to the core over a gRPC contract - the core never opens its database.

  • Schemas are the contract

    Resolvers, the data layer and the frontends' types are all generated from schemas, and a check fails the moment any of it drifts.

Project

Pre-1.0

Open from day one

Skelet is pre-1.0 and moving fast. Every release has notes and calls out what breaks. Bug reports and ideas are welcome as GitHub issues; we're not taking pull requests yet.

Get startedRead the docsChangelog