Skip to case study
All projects
Selected work03 / 04 · 2 min read

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.

Conceptual system sketch · not a product screenshot
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.

01 /

Catalog and cart flow

Connected product categories and brands with a session cart that supports adding, updating, removing and totaling items.

02 /

Accounts and orders

Implemented authenticated ordering and order models that represent pending and paid states.

03 /

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.

  1. Browse the catalog

    Product, category and brand models supply the catalog pages.

  2. Keep a session cart

    The cart stores its item dictionary in request.session and handles quantities and totals.

  3. Create an order

    Authenticated ordering connects the cart flow with persistent order records.

  4. 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.

01

Keep 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.

02

Store 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.

03

Use 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