Project case study ↘
Django E-commerce
Connect product discovery to an order and checkout.
The focus is the path through a shop: find a product, manage quantities, create an order and hand the payment step to Stripe. Separate Django apps organize each part of that flow.
- My role
- Developer · personal learning project
- Context
- Commerce workflows with Django and payment integration
- Project status
- Educational implementation
- Period
- Jan 2025 – Jan 2026
The challenge
Start with the problem.
The problem
A shopping flow must connect browsing and temporary cart state with authenticated orders and an external checkout. Each transition needs a clear place in the application.
The approach
Build a modular Django monolith with catalog, account, cart, order and payment apps. Store cart state in the session and create Stripe Checkout Sessions from the payment flow.
My contribution
From idea to implementation.
Catalog and cart flow
Connected product categories and brands with a session cart that supports adding, updating, removing and totaling items.
Accounts and orders
Implemented authenticated ordering and order models that represent pending and paid states.
Checkout and confirmation
Integrated Stripe Checkout Session creation and an order confirmation email flow.
Architecture
How the pieces connect.
A Django monolith divided into account, web, cart, order and payment apps, using ORM models, class-based views and server-rendered templates.
Browse the catalog
Product, category and brand models supply the catalog pages.
Keep a session cart
The cart stores its item dictionary in request.session and handles quantities and totals.
Create an order
Authenticated ordering connects the cart flow with persistent order records.
Start checkout
The payment view creates a Stripe Checkout Session; the project also includes paid-state and confirmation flows.
Tools of the build
- Python
- Django
- PostgreSQL
- Stripe
- JavaScript
Decisions
The thinking behind the code.
01Keep the shop in one Django application
Use separate Django apps for distinct commerce responsibilities within one monolith.
Why this choice / trade-off
A shared runtime keeps integration approachable; boundaries between apps still need care as the project grows.
02Store the cart in the session
Represent the cart with a dictionary managed through Django’s request session.
Why this choice / trade-off
This keeps temporary cart state simple, while persistence and cross-device continuity depend on session behavior.
03Use hosted Stripe Checkout
Create a Checkout Session and delegate the payment interface to Stripe.
Why this choice / trade-off
Hosted checkout reduces payment UI work; reliable payment-state reconciliation remains a separate engineering concern.
The result
What the project delivers.
A catalog organized by products, categories and brands.
A session cart with quantity updates, item removal and total calculation.
An ordering flow connected to Stripe Checkout Session creation and confirmation email logic.
What I learned
A checkout integration spans several kinds of state: session data, persistent orders and an external payment session. Following those transitions makes the boundaries and responsibilities of each Django app easier to reason about.
Follow the evidence
Go deeper into the implementation in the source repository.
Keep exploring
Let’s build something useful.
Get in touch