Build Project

Inventory Management · 4 stages

Home › Apps › Inventory Management
📦 Build Project · 4 stages

Build an inventory app.
Track products, stock, suppliers.

A complete inventory management system built in four stages. You start with a static interface, add JavaScript state and CRUD, connect it to a Python Flask backend with SQLite, and package it as a desktop application with PySide6. Same four-stage path as the CRM — different domain, new concepts: numeric columns, stock-level indicators, low-stock warnings, and summary calculations.

~8–12 hours total Beginner → Intermediate HTML · CSS · JS · Python
Why inventory The 4 stages The tech stack The data model All apps

How to use this page. Read "Why inventory" to see what this app teaches that the CRM didn't. Then pick a stage from the four cards. Each stage is a complete, runnable project on its own. If you've built the CRM, you'll recognize the pattern immediately and move faster. If you haven't, this app teaches the same concepts from scratch.

✅ Why build an inventory app

New domain, new UI patterns, same architecture.

Numeric columns

Prices, costs, quantities. Sorting and totaling numbers is different from sorting strings. Real table formatting matters.

Stock-level indicators

A visual cue for "in stock", "low stock", "out of stock". Color-coded badges that respond to data.

Low-stock warnings

Products below their reorder threshold are flagged. A live count in the header. A filter to show only those.

Summary calculations

Total inventory value = sum(quantity × cost). Item count. Average price. Derived from the data, updated on every change.

Two related tables

Products and suppliers. A foreign key relationship. This is your first multi-table app — a step up from the CRM's single table.

Real business domain

Inventory is a real business problem. The app you build here is a starting point for a real tool.

✅ The four stages

Each stage is a complete, runnable app.

✅ The tech stack

Same as the CRM, with a different domain.

HTML + CSS Grid

Semantic layout. Grid for the shell. Flexbox for the header and KPI cards. Custom properties for the dark theme.

Vanilla JavaScript

State → render → event → state. Same pattern as the CRM. No framework. The loop you'll use for the rest of your career.

localStorage (Stage 02)

Client-side persistence. Simple, synchronous, per-device. Replaced by a real backend in Stage 03.

Python + Flask

A minimal REST API. Six routes. Two tables. Foreign keys. Validation at the boundary.

SQLite

A single-file database. Two tables (products, suppliers). Foreign key from products to suppliers. Still no server.

PySide6 (Stage 04)

Qt for Python. The desktop UI. The same widgets as the CRM: QTableWidget, QComboBox, QLineEdit, QDialog.

PyInstaller

Packaging. One command. An executable. Ship it.

New: decimal numbers

Prices and costs are decimals, not floats. Python has Decimal. SQLite stores them as TEXT. A lesson in its own right.

✅ The data model

Two tables. One foreign key. Realistic relationships.

data-model.js
// Supplier
{
  id: number,
  name: string,
  contactEmail: string,
  contactPhone: string,
  createdAt: string,
  updatedAt: string
}

// Product
{
  id: number,
  sku: string,             // unique, e.g. "SKU-001"
  name: string,
  category: string,        // e.g. "Electronics"
  price: number,           // sale price, decimal
  cost: number,            // purchase cost, decimal
  quantity: number,        // current stock level
  reorderLevel: number,    // threshold for low-stock alert
  supplierId: number | null,
  createdAt: string,
  updatedAt: string
}
{
  id: 1,
  sku: "SKU-001",
  name: "Wireless Mouse",
  category: "Electronics",
  price: 29.99,
  cost: 15.50,
  quantity: 42,
  reorderLevel: 10,
  supplierId: 1,
  createdAt: "2026-11-11T09:00:00Z",
  updatedAt: "2026-11-11T09:00:00Z"
}

{
  id: 1,
  name: "Acme Electronics Ltd",
  contactEmail: "sales@acme-elec.com",
  contactPhone: "+92 42 1234567",
  createdAt: "2026-11-01T08:00:00Z",
  updatedAt: "2026-11-01T08:00:00Z"
}

Why SKU is unique

It's the stock-keeping unit — a real business identifier. Two products with the same SKU would be a data error. The database enforces uniqueness.

Why price and cost are separate

Cost is what you paid. Price is what you sell for. Margin = price - cost. Different fields, different purposes.

Why reorderLevel

A threshold per product. When quantity <= reorderLevel, the product is "low stock." A per-product value, not a global one.

Why supplierId is a foreign key

A product belongs to a supplier. The database enforces the relationship. Deleting a supplier with products requires a decision (cascade or restrict).

❓ Frequently asked

What will I build in this project?

An Inventory Management app. It tracks products (SKU, name, category, price, cost), stock levels (quantity, reorder threshold), suppliers (name, contact), and low-stock alerts. The app lists products in a searchable, filterable table, shows stock value summaries, and flags items below their reorder threshold.

How is this different from the CRM project?

The CRM tracks customers and leads — people and sales. The inventory app tracks products and stock — items and quantities. The four-stage structure is identical, but the data model is different, and the UI has new concepts: numeric columns, stock-level indicators, low-stock warnings, and summary calculations.

Do I need to complete the CRM first?

No. Each app is self-contained. If you've done the CRM, the patterns (state → render, Flask + SQLite, PySide6 + PyInstaller) will be familiar — you'll move faster. If you haven't, this project teaches the same concepts from scratch.

What's the data model?

Two tables. products: id, sku, name, category, price, cost, quantity, reorder_level, supplier_id, timestamps. suppliers: id, name, contact_email, contact_phone, timestamps. A product belongs to one supplier. The app shows all products, filters by category, searches by name or SKU, and highlights low-stock items.

Why SQLite and not Postgres?

Because the app runs on the user's machine. SQLite is a single file with no server, no setup, no credentials. For a real multi-user inventory system in production, you'd use Postgres or MySQL. The patterns (SQL, REST API, transactions) are the same.

Can I extend this app after the four stages?

Yes. Common extensions: purchase orders (stock in), sales (stock out), supplier comparison, stock history, barcode scanning, CSV import/export, low-stock email alerts. Every extension uses the same patterns: add a table, add a route, add a UI section.

🔗 Continue learning

🎨 Start with Stage 01: Interface
Build the visual shell — header, KPI cards, product table. 1–2 hours.

Or jump ahead if you know the earlier stages:

← All applications
Inventory Build · 4 stages