Simplites — Building an All-in-One Business Platform for Small Production Businesses

Overview

Simplites is a multi-module business management platform and website builder for small production businesses: custom cake shops, food manufacturers, pharmaceutical distributors, and similar SMEs in Indonesia. It ships orders, inventory, CRM, accounting, a visual shop map, a no-code website builder, marketing attribution, booking, and more — all in one self-hosted SaaS with per-module entitlements. No point-tool sprawl, no per-seat pricing, no cloud lock-in.

The Problem

Who It's For

Small production business owners with 2–15 staff. Custom cake shops, food producers, and similar businesses that take custom orders via WhatsApp, produce in a physical kitchen with named rooms and zones, and serve a mix of walk-in, wholesale, and repeat clients. Some handle regulatory compliance (like pharmaceutical CDOB requirements) alongside day-to-day order fulfillment.

The Real Pain

• Orders live in WhatsApp threads, not a system. A custom cake order arrives as a 15-message thread: the design, the size, the pickup date, the deposit confirmation. There's no way to move that into a trackable workflow without re-entering everything manually. Staff miss stages. Deposits get forgotten.
• Recipe costs are guesswork. BOM (bill of materials) costs aren't tracked against current ingredient prices. A shop owner might know the recipe but not whether the selling price is still profitable after flour or butter prices changed last month.
• Production visibility requires physically walking the floor. Managers text staff to check status. There's no dashboard showing who's in which room, what stage they're on, which tasks are urgent.

The core insight: small production businesses don't fail for lack of tools. They fail because every available tool assumes a model of work — one user, linear process, always-online — that doesn't match their reality: multiple staff, branching workflows, mixed internet quality, and work that happens in physical space.

Goals & Success Criteria

North star: A tenant can run their full daily operation, from order intake to delivery, inside Simplites with no parallel WhatsApp or spreadsheet tracking.

Supporting goals:

• New tenant onboards and takes their first order within 30 minutes of setup
• BOM cost visible on every product, updated automatically when ingredient cost changes
• Staff complete daily tasks from the dashboard without needing a manager to assign them each morning
• Admin pulls a revenue/profit report for any date range in under 60 seconds

Non-goals:

• Not a general-purpose ERP for large enterprises or manufacturing at scale
• Not a payments processor (wallet/multi-currency tracks balances, doesn't move money)
• No automated outbound messaging (WhatsApp Business API, SMS) — only wa.me deep links that staff trigger manually
• No third-party marketplace integrations at launch (Shopee, Tokopedia)

Discovery & Research

The starting point was watching real workflows, not reading market reports.

Initial research came from two family businesses used as early users. One was a VMI (inventory management system) built for my dad's company (BSN, a pharmaceutical raw-material distributor). The other was observing how custom cake shops like Pelangi Cake operate — a shop my mom has ordered from for years, including apparently my own birthday cakes. Feedback from BSN was immediate and specific: "this dropdown makes no sense when we're receiving stock from three suppliers at once." That kind of live feedback is hard to replicate in a standard user interview.

Key finding: small business software fails not because it lacks features, but because it assumes a model of work the actual business doesn't match. The system has to map to how the business already operates.

These two use cases are very different. Pelangi Cake takes custom orders via WhatsApp, tracks production stages per order (design, baking, decorating, pickup), and manages ingredients and recipe costs. BSN, on the other hand, is a pharmaceutical raw-material distributor operating under CDOB regulatory requirements, with 27 formal SOP documents covering everything from purchasing and quality control to regulatory submissions and warehouse management.

Building a workflow engine generic enough to handle both — custom cake order stages and pharmaceutical SOPs with branching logic, role gates, and a full SOP reference library — without making either feel over-engineered, is the core architectural challenge Simplites solves. That validated the decision to invest in a proper workflow engine early, not a simplified order-status field.

Design Decisions

1. WA message parser instead of WA Business API integration

Build a "paste WA message" input that parses the text against a configurable template and pre-fills the order form.

Why: WA Business API requires a BSP partner, additional cost per message, and ongoing maintenance. The parser requires zero external dependencies and zero API costs. Users already copy-paste text in their workflow constantly, so the mental model is already there.

Tradeoff: Not automated — still requires a manual paste. Accepted because the paste is already the user's existing habit; we make the downstream form-fill instant instead of manual re-entry.

2. BOM cost computed at query time, never stored

cost_per_unit on products is never persisted. Always computed live: SELECT SUM(b.qty_per_unit * i.cost_per_unit) FROM bom_items b JOIN inventory_items i.

Why: Stored cost drifts silently when ingredient prices change. A custom cake shop that received a butter delivery at a new price sees the margin impact immediately on every affected product — no manual refresh needed.

Tradeoff: More expensive queries. Irrelevant at small-tenant scale.

3. Shop Map as a first-class navigation view

The visual floorplan of the production space — rooms, staff, active tasks, zone status — is a primary nav item, not buried in settings or reports.

Why: Production-floor managers think spatially. "What's happening in the decorating room right now?" is a question asked many times a day. The map makes it a 2-second glance. Without it, the answer requires a phone call or physically walking over.

Tradeoff: More complex to maintain (room layout, zone assignment, real-time task counts per zone). Worth it because it's the view that makes Simplites feel designed for production businesses rather than generic service businesses.

4. Multi-tenant isolation from day one, per-tenant SQLite databases

Every table has tenant_id. Each tenant gets their own UUID-named SQLite database file at deploy time.

Why: Per-tenant DB isolation means one tenant's data never touches another's at the DB level. Multi-tenant architecture locked in early avoids a painful migration later. SQLite over PostgreSQL means no separate database process to crash and no server-level DB administration for the tenant.

Tradeoff: More complex deploy (per-tenant DB paths). Handled by a ship-tenant.sh onboarding script.

5. Modules sold and gated independently via entitlements

Core app, Website Builder, Cake Builder, Quotation/Paper Optimizer, Pharma CDOB, Booking, and Marketing are each independently entitlement-gated. A tenant only pays for and sees what they've licensed.

Why: A custom cake shop doesn't need pharmaceutical CDOB receiving. A quotation business doesn't need a cake builder. Forcing everyone to pay for everything reduces perceived value and creates UI clutter for features that aren't relevant.

Tradeoff: More complex access control logic (entitlement checks throughout). Handled once in a centralized entitlements table and enforced in bootstrap.

6. Cozy visual design over neutral/enterprise aesthetic

Warm color palette, Baloo 2 + Nunito typography, emoji in stage names, intentionally "cozy" visual tone throughout.

Why: Early user feedback consistently described alternatives as "cold and complicated." Small shop owners work in warm physical environments. A tool that matches that tone gets used; one that doesn't gets abandoned after the first week.

Tradeoff: Harder to position for larger or more formal businesses. Accepted: the target user is explicitly small production businesses, not enterprise.

Key Features Shipped

Orders

• 6 order types: Sales Order (workflow stages + task checklists + advance gating), Purchase Order (linkable to SO for pass-through margin), POS Quick Sale (receipt screen), WhatsApp Order (paste-to-parse), Pesanan Indent (pre-order with deposit tracking), Titip Jual (consignment with commission)
• Calendar view, Kanban board view, custom order numbering
• Payment tracking (partial, full), courier assignment

Inventory

• Batch tracking with expiry alerts, low-stock notifications, unit conversion (buy by crate, sell by bottle)
• Stock Opname (collaborative physical count with multi-staff simultaneous entry, batch-level discrepancy logging, finalize-locks)
• Pharma CDOB receiving mode for regulatory compliance

Products & BOM

• Recipe cost computed live from current ingredient prices, margin alert at <20%
• Product variants with per-variant BOM overrides
• Product documents with version management

Shop Map

• Visual floorplan with zone status (Idle/Pending/Active/Urgent), task counts, staff positions
• Slide-in zone detail panel with active orders, pending tasks, stage progress

CRM

• Customers and suppliers with flexible billing (per-delivery or monthly invoice bundles)
• Birthday vouchers, CAC tracking, CSV import
• Business Partner Program: partner scorecard auto-computed from real PO/courier data, incident logging with severity

Accounting

• Full double-entry bookkeeping, P&L, Balance Sheet, Cash Flow reports
• Tax summary, CEISA (customs) tracking, asset depreciation scheduling
• Multi-currency wallet (USD, CNY, EUR, SGD and more; IDR reporting)

Booking

• Time-based appointment/slot booking per product with configurable open hours and breaks
• Per-variant DP overrides, venue-wide capacity cap
• Public booking page via Website Builder; booking-to-order linkage with DP line items

Website Builder

• 20+ drag-and-drop content block types, blog/portfolio, product catalog, e-commerce cart, custom domains
• Quiz builder, customer feedback board (kanban), pricing calculator, referral program module
• Per-tenant theming (color palette + font per site), mobile preview toggle (in progress)

Referral Programs

• In-site referral program with tier-based rewards, per-product reward overrides, coupon and cash claim types
• External program support: referrers get a code (e.g. KOL-KYLA), referred person redeems it via a public page that draws from a pre-stocked discount code pool; admin manually confirms usage and credits the referrer — designed for products with no backend (first case: Propti)
• Program Mitra Simplites: 15% recurring reward for tenants who refer other businesses to Simplites

Marketing Module

• Campaign and effort tracker with 18-tactic playbook
• Three-tiered attribution (hard/voucher, self-reported, window correlation) — honest, never sums across confidence levels
• Live computed results at read time; no stored attribution numbers

Documents & Forms

• Drag-and-drop form builder with data-source dropdowns (live tenant data: Contacts, Products, Inventory), cascading dropdowns
• Document generation (HTML/CSV/PDF), bulk print, configurable paper sizes
• Live builder preview embeds the real order-entry form in read-only mode (zero backend calls)

Production

• Produce-to-Stock: record a production run that consumes BOM ingredients and replenishes finished-good stock in one transaction, with full inventory movements and journal entry; voidable if no produced batch has been sold yet

Petty Cash (Kas Kecil)

• Imprest petty cash funds with a fixed ceiling per fund
• Staff submits claims with line items and receipts; owner approves/rejects per line; one-click replenishment auto-posts the correct journal entries
• Live balance always derived, never stored — can't drift

Staff Fraud Prevention

• Shift/till sessions, void requires manager PIN, discount approval gates, activity log per staff member

Onboarding

• 9-step Getting Started checklist, per-user completion state, re-openable anytime

Admin (Cross-Tenant)

• Cross-tenant usage dashboard: per-subscriber orders/contacts/storage/plan status
• Tenant provisioning, entitlement management, billing queue

Metrics & Outcomes

• BSN (first enterprise tenant, pharmaceutical distributor) brought 27 pharma SOPs live as verifiable, role-gated workflows within 6 weeks of initial deployment — no custom engine required, the generic workflow schema handled it all
• Onboarding checklist gets new tenants to first order entry in under 30 minutes
• Pre-launch: running on production for real tenants before official public launch
• Priced at Rp 250,000/month
• 100+ features shipped across ~90 planning documents in approximately 4 months (Mar–Jun 2026)

Lessons Learned

Generic schema pays off fast. The workflow engine was designed for custom cake order stages (design, baking, decorating, pickup). The same engine, without modification, handles BSN's 27 pharmaceutical SOPs with branching logic, CDOB compliance stages, and a full SOP reference library. If the schema had been shaped to the first use case, the second tenant would have triggered a rewrite.

The first tenant's edge cases are a gift. BSN's pharmaceutical use case required things a custom cake shop never would: branching workflow stages, role-gated task completion, a document reference library, CDOB receiving modes. Every one of those features made the platform stronger for every future tenant. Edge cases from engaged early users are free product research.

Honest attribution beats fake precision. The Marketing module computes revenue attribution in three tiers with different confidence levels, labeled clearly, never summed into a single number. The instinct was to show one clean revenue number. The right call was to show three honest numbers and let the tenant understand what's proven versus correlated. That framing builds trust; false precision erodes it.

Offline-first philosophy doesn't mean no server. Simplites is self-hosted SaaS. But the design principle of "works in degraded conditions" shows up everywhere: SQLite over PostgreSQL (no separate DB process to crash), server-side rendering over client-heavy SPAs, WA paste parser over API integration. Fewer moving parts fail less often.

Tech Stack

• Frontend: SvelteKit, Tailwind CSS, Google Fonts (Baloo 2 + Nunito)
• Backend: PHP 8+, SQLite 3 (per-tenant isolated databases)
• Auth: session-based, role and zone access control

CTA

Simplites hasn't officially launched yet but is close. If you're curious, simplites.com