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.
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.
Interface
Build the visual shell — header, KPI cards (total value, item count, low-stock count), product table with SKU, price, quantity, stock status. Styled with CSS Grid and design tokens.
Interactions
Make it work. Add/edit/delete products, filter by category, search by name or SKU, low-stock-only toggle. localStorage persistence. Live summary totals.
Backend
Move the data to Python Flask + SQLite. Two tables (products, suppliers). REST API with 6 routes. The UI stays the same. Only the storage layer changes.
Desktop
Rebuild the inventory app as a native PySide6 desktop app. Package it as an installable .exe or .app. Bundle the SQLite database inside.
✅ 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.
// 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
Or jump ahead if you know the earlier stages: