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 follow REST conventions and return JSON. Versioned at /api/v1/ so breaking changes never surprise your frontend.
// Fetch the product catalog // Replace with your deployed domain const response = await fetch( "https://your-domain.com/api/v1/products/", { method: "GET", headers: { "Content-Type": "application/json", "Authorization": "Token <your-token>" } } ); const data = await response.json(); // → { count: 42, results: [ ... ] } // POST a new cart item await fetch("/api/v1/carts/", { method: "POST", body: JSON.stringify({ product_id: 7, quantity: 2 }) });
Structured for the real world — clean separation of concerns and a clear path to microservices when you're ready.
Business logic lives in a dedicated services/ layer — separate from views and models. Keeps API handlers thin, and logic testable in isolation.
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 — exceptions, base serializers, permissions — centralised in core/ so they're consistent across every app.
One docker compose up gives you Django + PostgreSQL running together. The compose file lives in docker/, keeping the project root clean.
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.
JWT/Token auth with role-based access. Guest checkout included.
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.
js/docs.js to fetch live from GitHub.
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 fileAdd a .env file in the project root with your database credentials and secret key.
cp .env.example .env && nano .env
Builds and runs Django + PostgreSQL together inside containers.
docker compose --env-file .env -f docker/docker-compose.yml up --build
Django listens at http://localhost:8000. Try the products endpoint to verify it's running.
curl http://localhost:8000/api/v1/products/
Open source, MIT licensed, actively maintained. Fork it, extend it, ship with it.