Product Catalog
Full product management — create, update, categorise, and query products at scale. Variants and inventory tracking on the roadmap.
Sellaris is a modular, API-first Django backend — handling products, carts, orders, payments, and more. Drop it in, wire up your frontend, and ship faster.
Every module your e-commerce service needs — cleanly separated, independently deployable, and ready to extend.
Full product management — create, update, categorise, and query products at scale. Variants and inventory tracking on the roadmap.
Session-aware cart handling with add, update, and remove operations. Coupon support planned as the project matures.
Let users save products for later. Wishlist endpoints are fully available and tied to user accounts.
End-to-end order lifecycle — creation, status management, and tracking. Supports both guest and authenticated users.
Payment endpoint is live and ready for Flutterwave and Paystack wiring. Secure verification in progress.
Authentication, registration, and profile endpoints. Guest checkout support and role-based access on the roadmap.
Notification module scaffolded and ready. Email notifications via Celery are coming — the architecture already supports async tasks.
One command spins up the entire stack — Django, PostgreSQL, and future Redis/Celery — all containerised and environment-configured.
All endpoints return JSON and are versioned under /api/v1 and /v1. Session auth, guest ownership, and staff-only routes are all documented explicitly.
// Guests can shop with a Django session // Keep cookies enabled so cart and order ownership persists await fetch("/api/v1/carts/cart-items", { method: "POST", credentials: "include", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ product_variant: "6c6d7030-fd91-4d30-8a74-457b5f670001", quantity: 2 }) }); const checkout = await fetch("/api/v1/orders/checkout", { method: "POST", credentials: "include", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ email: "shopper@example.com", phone_number: "+2348012345678" }) }); const order = await checkout.json(); // Then initialize payment with order.id
Structured for the real world — clean separation of concerns and a clear path to microservices when you're ready.
Business logic is pushed into focused service modules where it matters most, especially around inventory, payments, email delivery, and ownership transfer.
Each domain (users, products, orders…) is an independent Django app under apps/. Add, remove, or replace domains without touching unrelated code.
Background jobs live in tasks/ and are Celery-ready. Hook in Redis and you have async processing with zero refactoring.
Cross-cutting concerns — permissions, pagination, filters, validators, and helper utilities — centralised in core/ so behavior stays consistent.
Development and production both run from root-level Compose files, with Nginx, health checks, Redis, Celery workers, and TLS automation wired in.
Because apps are decoupled and communicate via service layers, breaking Sellaris into microservices later is a refactor — not a rewrite.
Sellaris is actively developed. Here's what's in progress and what's planned.
Flutterwave & Paystack — gateway hooks are in place.
Session auth with CSRF-aware browser support, guest checkout, and shopper-data transfer after login.
Rate limiting, input validation, and secure payment verification.
Size, colour, and stock level tracking per SKU.
Real-time status updates from placed → fulfilled.
Transactional emails sent asynchronously via Celery.
DRF throttling + Redis-backed rate limiting per user/IP.
Enhanced Django admin with analytics and order views.
Read about how Sellaris works, how to deploy it, and how to integrate it with your service.
docs/docs/v1/. The machine-readable contract lives at openapi/sellaris-v1.yaml.
Sellaris undergoes routine testing to ensure every module keeps working as the codebase grows.
CRUD operations, list filtering, and pagination covered with unit and integration tests.
Add-to-cart, update quantity, and remove-item flows tested end-to-end via the DRF test client.
Order creation and status transition tests being written as the order module stabilises.
Mock gateway responses being introduced for payment unit testing.
Full token auth and permission boundary tests planned alongside the auth module.
Performance and throttling tests scheduled after rate limiting is implemented.
All you need is Docker and Docker Compose. No local Python setup required.
Pull Sellaris from GitHub to your local machine.
git clone https://github.com/occupythemind/sellaris-backend.git
.env.local fileAdd a root-level .env.local file with database credentials, payment config, and callback paths.
nano .env.local
Builds and runs Django + PostgreSQL together inside containers.
docker build -t sellaris:latest -f Dockerfile . && docker compose --env-file .env.local -f docker-compose.yml up -d
Django listens at http://localhost:8000. Try the health check and the catalog endpoint to verify it is running.
curl http://localhost:8000/health/ && curl http://localhost:8000/api/v1/products/products
Open source, MIT licensed, actively maintained. Fork it, extend it, ship with it.