Katana starts at $299/month and real bills hit $747–$1,095 with add-ons; MRPeasy charges per user. For workshops under 50 people doing simple assembly, here's the BOM-ready alternative.

The Problem

You run a workshop, not a factory. Five, ten, maybe twenty-five people. You assemble furniture kits, pour candles, blend coffee, box electronics kits, pack supplements — pick your trade. Your “manufacturing process” is a recipe: 2 of this, 1 of that, fifteen minutes at the assembly table. Your entire planning need is two questions:

1. What can we still make today?
2. What did this batch actually cost us?

For those two questions, the manufacturing software market offers you this:

Tool	Entry price (2026)
Katana	$299/month (Core) — before add-ons
MRPeasy	$49–149 per user / month
Odoo Manufacturing	$31.10+ per user / month (Enterprise plans)

Micro-manufacturers — shops under 50 people — are the segment the MRP market overcharges most systematically. You get quoted enterprise vocabulary (multi-level routings, finite-capacity scheduling, shop-floor terminals) at prices that assume you employ a production planner. You don’t. You have a table, a recipe list, and a Shopify store.

A Typical Workshop Profile

A 6-person workshop: 18 finished SKUs, each a 3–5 component assembly, selling on Shopify, restocking from four suppliers. A completely typical micro-manufacturer.

Katana’s pitch: Core plan at $299/month with unlimited users. Sounds reasonable — until the add-on ladder starts. Shop-floor tablets for the assembly table? That’s the Shop Floor app, an add-on. Barcode receiving on incoming components? Warehouse Management, an add-on. Lot tracking you’ll eventually be asked for by a retailer? Traceability, an add-on. Katana’s current pricing page (August 2026) makes the ladder explicit — Core $299, then à la carte: Traceability $249/month, Manufacturing $199/month, Warehouse Management $149/month. A workshop that needs lot codes, routing, and barcode receiving configures to:

Core                    $299
+ Traceability          $249
+ Manufacturing         $199
+ Warehouse Management  $149
─────────────────────────────
Configured              $896/month

Working from Katana’s public add-on price ladder (August 2026), a typical real-world bill lands around $747–$1,095/month once those attach — and inventory locations and sales-order volume are billed on usage, so the bill grows with you. To be fair in the other direction: if Core alone covers your process, $299 with unlimited users is honest pricing. The ladder only matters when your process needs the rungs.

MRPeasy’s pitch: $69/user/month on the Professional plan. But per-user means every user — the assembly-table tablet counts, and so does your accountant. Six people: $414/month, forever.

The alternative is not another subscription. A BOM is a row per component — that’s the whole data model a small workshop needs before any MRP system earns its keep.

That’s $3,600–$9,600 per year in software rent to manage 18 recipes and answer two questions.

What These Tools Genuinely Get Right

Fairness first — these are good products:

• Katana has the best real-time inventory-plus-sales sync in its tier and a genuinely clean UX. Unlimited users on Core is honest pricing for the tier above you. There’s even a free plan — capped at 30 SKUs, which a workshop blows through the moment you count components, not just finished goods.
• MRPeasy is serious classical MRP — scheduling, capacity planning, stock control — at a fraction of big-ERP prices. If you have a production planner whose job is to feed it, it earns its bill.
• Odoo is the full-ERP safety net: accounting, CRM, inventory, manufacturing under one roof, with a huge ecosystem of implementers.

The problem isn’t quality. The problem is that all three are priced and architected for the tier above micro-manufacturing — and none of them will bill you less for using 10% of the feature surface.

The Hidden Costs Beyond the Invoice

1. The pricing ladder scales with you, not your value

Katana’s add-ons and usage-based billing, MRPeasy’s per-user seats, Odoo’s per-user apps — every growth path in SaaS MRP means a bigger monthly bill. Adding a scanner at the second workbench shouldn’t be a pricing event.

2. You rent complexity you will never open

Multi-level BOMs, finite-capacity scheduling, MRP runs, subcontracting flows, shop-floor terminals. A micro-manufacturer needs single-level BOMs, a coverage check, and a cost roll-up. That’s roughly 10% of the feature surface — billed at 100%.

3. Cloud dependency on a workshop connection

Assembly tables live in industrial units with the Wi-Fi quality you’d expect. Cloud MRP stops at the loading dock: no connection, no receiving, no production logging. Your workshop shouldn’t idle because the router blinked.

4. Your recipes live in their database

A BOM is your IP — your product deconstructed. In multi-tenant SaaS it lives in their tenant, and the export you’ll get is CSVs. When prices creep 10–20% annually (they do), switching costs keep you paying.

What a Micro-Manufacturer’s System Actually Looks Like

Here’s the part most MRP vendors won’t show you: the data model behind “manufacturing software” for simple assembly is small. You can inspect a working foundation right now — it’s live at demo.kamensky.dev:

Table	What it holds
variants	Every SKU — sellable and consumable — with cost and price
purchase_items	Every supplier receipt line, unit_cost preserved per receipt
inventory_movements	Append-only ledger: in / out / adjust, each row linked to its source (purchase, order, quality case)
orders / order_items	Sales history with the sold unit_price preserved as a business fact
quality_cases	Supplier receipt defects, customer returns, internal inspections — with a status workflow

Two properties matter more than any feature list:

• Stock is computed, not typed. Every quantity is derived from the movement ledger. There is no editable “current stock” field to drift from reality — the exact failure mode that kills inventory spreadsheets at 10k SKUs.
• Cost is history, not a field. Every purchase line keeps its unit_cost. When a component’s price jumps from $2.40 to $3.10, last quarter’s batch cost doesn’t silently change — which is precisely what production cost accounting is supposed to guarantee.

On top of that foundation, a bill of materials is not exotic: a BOM is one row per component (what you sell, what it consumes, how much, plus scrap allowance), and a production order is a workflow plus two ledger entries — components out, finished SKUs in. Batch cost comes straight from the component unit costs in actual purchase history, plus labor and overhead lines.

“What can we still make today?” becomes one query per finished SKU — component coverage against the same ledger that already feeds your sales and purchasing views.

Honesty first: what’s live, and what’s built per client

The demo proves the foundation: the movement ledger, the preserved cost history, quality cases, offline sync, and the deterministic 5-stage migration pipeline. The manufacturing module itself — BOM management, production orders, batch cost roll-up — is not a checkbox on a public pricing page. It’s configured per client on that foundation.

For a workshop with 10–50 single-level assemblies, that’s a small, fast build: the schema is ready for it, and the integrations (Shopify finished-goods sync, supplier purchase orders, accounting export) use the same connector patterns the demo already runs. The finished system keeps running on a budget VPS — $4–6/month infrastructure, unlimited users, no per-seat pricing ever.

That’s the whole difference in one sentence: SaaS MRP rents you the entire factory-software catalog at enterprise tiers; a tailored build pays once for the 10% you’ll actually use, on a data model you can inspect today.

Pricing Comparison

	Katana Core + add-ons	MRPeasy (6 users)	Odoo Enterprise (6 users)	Tailored on the ak-ops foundation
Monthly	$299 → $747–1,095	$414	$187–366	$4–6 (VPS)
One-time	$0	$0	implementation partner	build (quoted after scoping)
Users	unlimited (Core)	per-user	per-user	unlimited
Offline assembly table	no	no	no	yes — offline-first sync
Pays only for what’s used	no	no	no	by design
BOM & recipe data	their tenant	their tenant	their cloud	your SQLite file
Custom process fields	no	no	developer needed	by design

(Odoo footnote: the free Community edition doesn’t include the Manufacturing app — MRP lives in the paid Enterprise plans, and self-hosting those still bills per user.)

The Break-Even Math

6-person workshop, $400/month average MRP bill:

SaaS route:        $400/mo → $4,800/year → $24,000 over 5 years
                   (before the 10–20% annual price creep)

Tailored build:    $3,000–6,000 one-time + $6/mo VPS
                   amortized over 24 months ≈ $131–256/month

Break-even:        month 8–16
5-year savings:    ≈ $12,000–19,000 — and you own the system

When to Pick Which

Pick	If…
Katana	You have 30+ finished SKUs with multi-level BOMs or subcontracting, want zero setup, and the bill is genuinely fine for you
MRPeasy	You need real scheduling and capacity planning — and someone whose job is to maintain it
Odoo	You’re building a company-wide ERP (accounting + HR + CRM) anyway and have an implementation partner budget
Tailored build	You’re under 50 people, your assemblies are single-level, and you want offline operation, data ownership, and a fixed cost

The Migration Path

You don’t rip out the workshop’s routine overnight. Three phases:

Phase 1 — BOM audit (weeks 1–2). Most workshops keep recipes in Excel. They go through the same deterministic 5-stage pipeline as any spreadsheet migration: Analyze → Map → Clean → Validate → Import, with exact count tracking. Components and finished SKUs land in products / variants; purchase history lands in purchases / purchase_items with every unit_cost preserved.

Phase 2 — Configure the manufacturing module (weeks 3–4). bom_lines from your audited recipes, a production-order workflow mapped to how your table actually works, cost roll-up rules, and the integrations: Shopify finished-goods sync, supplier purchase orders, accounting export.

Phase 3 — Parallel run, then cut over (week 5+). The spreadsheet stays the source of truth for two weeks while both systems run; counts reconcile nightly; then you cut over and the assembly table goes offline-first — mutations queue locally, sync on reconnect.

The full discipline behind this is documented in the sheets-to-database migration demo — deterministic, count-tracked, reversible.

TL;DR

The problem	Micro-manufacturers (under 50 people) pay $300–1,100/month for MRP priced for the tier above them
The overkill	You need single-level BOMs, a coverage check, and cost roll-up — roughly 10% of the feature surface you’re billed for
The alternative	A BOM-ready foundation already live at demo.kamensky.dev: variants with cost history, an append-only movement ledger, quality cases
What’s built per client	BOMs, production orders, batch cost roll-up, integrations — a small build on a proven foundation, running on a $4–6/month VPS with unlimited users
The math	$3,000–6,000 one-time vs. $400/month rent → break-even month 8–16, five-year savings ≈ $12k–19k
Next step	Bring your BOM spreadsheet to the 20-min fit call — we will discuss your roadmap, the integrations, and the migration plan
Related	The Shopify Stack Tax · Google Sheets to SQL in One Transaction · Your Inventory Spreadsheet Will Break at 10k SKUs

---

Paying $300+/month to manage 20 recipes? I build the tailored version on the foundation you can test today, and migrate your BOMs with count-tracked discipline — book a free 20-minute fit call.