How to Read This Documentation¶

This documentation is written for developers who have purchased this project and want to understand, customize, and extend it confidently.

This is not a marketing document and not a beginner tutorial. It is a source-code–guided, developer-oriented documentation designed to help you build real products on top of this codebase.

What This Project Is¶

This project is a production-ready Django digital product selling platform.

Its primary goal is:

To sell digital products and manage the complete lifecycle around them (purchase → access → post-purchase support → extensions)

The codebase is written with real business use cases in mind, not tutorial examples.

Who This Documentation Is For¶

This documentation is for:¶

Indie hackers building and selling digital products
Small startups using Django as their core backend
Developers onboarding themselves or others into this codebase
Django beginners who are comfortable reading real production code

This documentation is NOT for:¶

Absolute Django beginners looking for step-by-step tutorials
Readers expecting UI/UX design guides

If you can read Django models, views, and services you are the right audience.

What You Should Be Able to Do After Reading¶

After reading this documentation, you should be able to:

Confidently customize existing features
Add new business flows without breaking existing ones
Onboard new developers by pointing them to the right sections
Understand why things are designed the way they are, not just how

How to Read This Documentation (Important)¶

This documentation is not meant to be read linearly like a book.

Different goals require different reading paths:

If you want to understand how the system works¶

Start with: - System Mental Model - Business Flows - Cross-App Dependency Map These explain why things are designed the way they are before showing how they are implemented.

If you want to customize or extend features¶

Focus on: - App-by-App Deep Dive - Shared Concepts - Customization Playbooks These sections show where to plug in your own logic safely.

If you are onboarding a new developer¶

Ask them to read: - How to Read This Documentation - System Mental Model - Business Flows - Then only the relevant app(s) from App-by-App Deep Dive This prevents random code edits without understanding dependencies.

⚠️ Do NOT start with App-by-App Deep Dive. That will break the mental model of how the system actually works and lead to wrong assumptions during customization.

Always understand the system flow first, then go into individual apps.

How This Documentation Is Structured¶

This documentation follows a top-down mental model approach:

First, you understand what the system is
Then, how business flows move across apps
Then, how apps depend on each other
Finally, how each app, file, model, and view works

Code is explained in context, not in isolation.

How Code Is Referenced¶

This documentation will not repeat full code blocks everywhere.

Instead, it will:

Reference files using paths (e.g. users/models.py)
Refer to specific models, views, or services
Expect you to open the code in your editor while reading

Example references:

seller/models.py → Product
payments/views.py → ProductDownloadView

This is intentional and keeps the documentation practical and maintainable.

Customization Philosophy¶

You are free to change anything in this codebase.

However, this project follows a clear philosophy:

You can change anything, but you must understand the consequences.

This documentation will clearly tell you:

What is safe to customize
What requires extra caution
What should only be changed if you fully understand the system

⚠️ Strong warnings will be added only in critical areas where changes can break core flows.

What This Documentation Does NOT Cover¶

This documentation currently does not focus on:

UI/UX design decisions
Styling or theming guides

These may be documented separately later.

Final Note Before You Continue¶

This project is product-first, not framework-first.

That means:

Business flows matter more than Django tricks
Ownership and responsibility matter more than file count
Understanding “why” is more important than memorizing “how”

If you keep this mindset while reading further sections, this documentation will make the entire codebase feel predictable and safe to extend.