We stopped designing. We started operating.
We stopped asking "how should this work?" and started asking "what breaks when this is used every day?"
Last update, we had Products and Manufacturers running — the foundation. Everything looked clean. Made sense. But it wasn't a system yet. It was two sections that happened to live in the same database.
Since then, we built four more sections. And somewhere in the middle of wiring them together, something clicked. The product stopped being a collection of pages and started feeling like something you could actually run a trade business on.
If an order exists, everything else must follow automatically.
That sounds obvious. Almost no system actually does it. So we rebuilt around that idea.
When you create an order now: production demand appears. Products get assigned to manufacturers. Timelines start forming. Logistics becomes inevitable. It's no longer tracking. It's orchestration.
The hub that connects everything.
Orders are no longer just records. They drive the system. A 13-state lifecycle — from draft through client approval, deposit, production, QC, shipment, customs, delivery, to completion. Kanban board, timeline view, and list view. The operator sees every order and where it stands in under 5 seconds.
The order detail page is mission control. One scrollable page that shows: line items with manufacturer assignments, production lot status with QC results, shipment tracking with ETA, financial P&L with landed cost, and a document checklist auto-generated by Incoterm and destination. Every entity is clickable — manufacturer name opens their profile, production lot opens the QC record, shipment opens tracking. You never leave the order to find what you need.
Where reality hits.
Production was messy at the beginning. Because in real life, production is messy. Factories delay. QC fails. Quantities shift. So instead of hiding that, we leaned into it.
We broke production into lots. Each lot belongs to an order, moves through 9 states, can fail, loop back for rework, restart. The QC rework loop was the design decision that changed everything — a lot can fail inspection, go back into production, get re-inspected, and the full history of every attempt is preserved on one record.
And one key rule: when a lot is released, it becomes real cargo. That's the handoff. That's where things stop being internal and start costing money.
Where things usually fall apart.
This is where we spent the most time. Because this is where most companies lose control. We kept asking ourselves: "If I had 10 containers on the water right now, can I answer where they are in 5 seconds?" At first, the answer was no. So we rebuilt it properly.
We didn't build a tracking page. We built a logistics control layer.
The demand side — with a full CRM inside.
742 paragraphs of spec. The largest section in the platform. Five tabs: Directory, Pipeline, Pricing, Financials, Overview. This isn't a contact list — it's relationship intelligence for trade operators.
The pipeline tracks every deal from lead to close. Won deals convert to draft orders with one click — client, products, and negotiated pricing pre-populated. Deal rot detection flags stale opportunities. Lost deals can be re-opened. Revenue forecasting rolls up pipeline and historical data. Gmail integration with a proposal editor that styles per-section. AR aging shows who owes what and how late. Credit management prevents over-exposure. Payment behavior scoring separates the reliable payers from the risky ones.
The part that matters most: it's connected now.
Before: orders lived somewhere. Production lived somewhere else. Shipments were separate. Now: order is created → production lot appears → lot finishes QC → becomes a shipment → shipment moves → gets delivered. No re-entry. No duplication. No guessing. One flow, one data model, one source of truth.
Three things became very clear.
382 tests. Every push verified.
We hit a point where building fast without breaking things required a safety net. So we built one. 382 automated API tests across 17 files. A git pre-push hook that blocks any code push unless every test passes and the frontend compiles clean.
Not just happy-path tests. Tenant isolation — company B can't see company A's data. Cross-section integrity — manufacturer pricing flows correctly into product buy-prices. Edge cases — unicode characters, SQL injection attempts, invalid UUIDs, boundary values. Error handling — malformed requests, missing headers, wrong content types. Every endpoint, every error path, every data flow between sections.
What's running right now.
Finance. Then the system is operational.
One section left to complete the core trade lifecycle: Finance. Invoicing, payments, three-way matching, cash flow, profitability with landed cost, multi-currency, tax compliance. After that, the full chain is live — from product catalog to client order to factory production to shipping container to delivered goods to invoice paid.
Then we move into the enhancement layers: Tasks, AI Services, Automation, and Intelligence Feed. And then we start plugging this into the PoV system.
This wasn't a clean build.
We rewrote parts of it multiple times. We broke things. We simplified things. We removed things that looked good but didn't work. We debugged CSS for hours because a native dropdown can't be styled on macOS. We discovered that Fastify's error handler scoping means you have to register it before the routes, not after. We learned that Recharts containers with 100% height render at -1 pixels before the DOM paints. Every one of those problems made the product better. And now it's starting to feel like a system, not a project.
