Commerce + content, one weave

Weave the
whole store
on one loom.

Loom is a multi-tenant website builder and commerce operating system. A visual Studio with 230 plus live elements, a headless Scribe CMS, a supplier catalog that feeds every seller store, and event-based trust scoring. One sign-in via Wenme, one checkout via LoneSock Pay, one canvas for content and commerce.

  • Section / Row / Column page builder
  • B2B supplier graph, B2C distribution
  • Cross-store trust scoring
  • Wenme passkeys, day one
Loom build manifest
cb01762
/workspace
Apps shipping in the monorepo
  • STOREStorefront
  • ADMINSeller admin
  • STUDIOTheme Studio
  • SCRIBEScribe CMS
  • PLATPlatform console
  • WWWloom.bd marketing
230+
Studio elements
Live in apps/studio
26
DB migrations
Loom + Scribe combined
6
Site verticals
Commerce, blog, services, more
537
TSX components
Across the apps/ workspace
Docker Swarm + Traefik

Counts pulled from the production Element Schema Registry and EF Migrations folder.

01 / What is Loom?
definition · for buyers and AI engines

Loom is the website builder with built-in trust, and the commerce operating system underneath it.

Loom pairs a visual Studio (Section, Row, Column, Element, the way Elementor users already think) with a headless CMS (Scribe), a B2B-to-B2C product catalog, and an event-based trust service. Sellers attach a domain, design pages in Studio, reference products from the supplier graph, and route checkout through LoneSock Pay. The same canvas builds an e-commerce store, a portfolio, a blog, a service-business site, a membership site, or an event platform.

The platform is .NET 10 backend, Next.js 16 frontend, Postgres 18 with row-level security for tenant isolation, RabbitMQ for trust events, MinIO for media, and Traefik plus Cloudflare for edge. Authentication is delegated to Wenme (passkeys), authorization to Darwan (policy-based access control), notifications to BitsPath, payments to LoneSock Pay. Loom owns the commerce, content, design, and trust logic on top of that shared core.

02 / Six apps, one repo

Storefront. Admin.
Studio. Scribe.
Platform. Marketing.

The Loom monorepo ships six Next.js apps and four .NET services in one workspace. Every surface a Seller, Supplier, Customer, or Platform operator touches is in the same tree, on the same deploy.

mono-repo
pnpm workspaces, six Next.js apps, four .NET services.
services
loom-api, loom-trust, loom-workers, scribe-api.
data
Postgres 18 with RLS, Redis cache, RabbitMQ events.
edge
Docker Swarm + Traefik on the loom.bd host.
  1. STORE

    Storefront

    apps/storefront
    Customer-facing stores on Seller domains

    Next.js 16 storefront serving every tenant. Cart, checkout, search, blog, product pages, collections, account portal, /preview for Studio iframe.

  2. ADMIN

    Seller admin

    apps/admin
    Tenant control plane

    Products, orders, customers, inventory, pricing, fulfillment. 21 API proxy routes wired to loom-api. Darwan-guarded routes per role.

  3. STUDIO

    Theme Studio

    apps/studio
    Visual page builder

    230+ element schemas, 196 renderers, drag-drop with dnd-kit, TipTap inline edit, per-breakpoint responsive controls, 3-second auto-save.

  4. SCRIBE

    Scribe CMS

    apps/scribe-admin
    Headless content backbone

    Spaces, content types, 18+ field types, GraphQL + REST, localization, preview tokens, scheduled publishing, version rollback.

  5. PLAT

    Platform console

    apps/platform
    Operator dashboard

    Platform users, tenant oversight, default themes, integration hub, support center, platform billing, ledger, analytics.

  6. WWW

    loom.bd marketing

    apps/www
    Public site

    The Loom marketing surface is itself built with Loom Studio and managed in Scribe. Dogfood by construction.

03 / Four pillars

The platform decisions that separate Loom from a CMS or a page builder.

Each pillar is a load-bearing capability already shipped in the monorepo. None are roadmap items.

01

Theme Studio

Section, Row, Column, Element.

The hierarchy WordPress + Flatsome + Elementor users already know, in a single rebuilt canvas. Auto-save every 3 seconds, version history, real-time collaboration cursors, per-breakpoint controls, TipTap inline editing.

02

B2B to B2C catalog

Suppliers publish once, sellers list anywhere.

Suppliers own product truth: specs, variants, MOQ, lead time, images. Sellers reference, set retail price and stock. No duplicated SKUs across the network, no copy-paste, no cover-image rot.

03

Loom Trust

Event-based fraud detection, invisible to shoppers.

Order, payment, and fulfillment events flow into a scoring service over RabbitMQ. Each shopper carries a risk band across every Seller store. Sellers see Low / Medium / High, customers see nothing.

04

Pluggable modules

Extend without forking the platform.

Internal app system with billing integration. Modules ship as opt-in capabilities per tenant, gated through the Module Management UI. No WordPress-style plugin chaos, no theme-update break-glass.

04 / Scribe CMS

The headless content backbone, bundled.

Scribe is the headless CMS that ships inside Loom. Content types and 18 plus field types, GraphQL plus REST, field-level localization, preview tokens, scheduled publishing, version rollback, and 8 plus webhook events. Studio elements render Scribe entries the same way they render storefront product grids, so a landing page that mixes editorial copy with live product cards is one canvas, not two integrations.

Content types
Schema-driven
Field types
18+
APIs
GraphQL + REST
Publishing
Scheduled + preview

Blog posts

01

Rich text, hero, tags, scheduled publishing.

Pages

02

Marketing pages, terms, about, contact.

Landing pages

03

Campaign-scoped, A/B-ready, template-driven.

FAQ + testimonials

04

Structured content rendered by Studio elements.

05 / How Loom compares

Loom vs Shopify, WordPress + WooCommerce, Webflow.

The honest comparison. Each of these platforms is excellent at what it was built for. Loom is the only one that ships a visual builder, a headless CMS, a B2B catalog, and cross-store trust in a single multi-tenant SaaS.

CapabilityLoomShopifyWordPress + WooWebflow
Visual page builder included
230+ elements, Studio v3
Liquid + theme code
Elementor / Divi add-on
Headless CMS in the same product
Scribe CMS
Apps + Hydrogen DIY
CMS Collections (limited)
B2B supplier graph feeding B2C stores
Cross-store customer trust scoring
Multi-tenant SaaS, no plugin maintenance
Passwordless auth (passkeys / WebAuthn)
Wenme, default
Add-on apps
Plugin
Wix Identity equivalent
Bangladesh payments (bKash, Nagad, Rocket)
LoneSock Pay
3rd-party gateways
Plugin-per-gateway
Self-hosted on customer infra (sovereign data)
Docker Swarm + Traefik

Capability claims for Shopify, WordPress + WooCommerce, and Webflow based on public documentation as of 2026 Q2. Speak to vendors for current matrices.

06 / Launch path

Four steps from passkey sign-in to a published storefront.

The seller flow assumes zero hosting knowledge. Most single-store sellers reach publish on the same afternoon they sign up. Custom domains add a DNS round-trip; the wildcard subdomain works instantly.

  1. Step 01

    Sign in with Wenme

    One button on apps/admin. Passkey or magic link. Tenant is auto-provisioned, default theme cloned, Scribe space created in a single workflow.

  2. Step 02

    Attach a domain

    Add a custom domain in admin. Loom emits a TXT record, the background worker verifies it, then Traefik issues SSL through Cloudflare for SaaS. Wildcard subdomain on the loom.bd platform works the moment the tenant is born.

  3. Step 03

    Design in Studio

    Drag from the 230+ element catalog onto the Section / Row / Column canvas. Auto-save runs every three seconds. Per-breakpoint controls let one layout cover mobile, tablet, and desktop without forks.

  4. Step 04

    Pull catalog and publish

    Reference supplier products into your assortment, set retail prices and stock, route checkout through LoneSock Pay. Hit publish, the storefront serves customer traffic over Next.js ISR.

07 / KaritKarma footprint

Built on the platform we already operate.

Loom is a KaritKarma product. Authentication, authorization, communications, and payments are inherited from the shared core so the Loom team can focus on commerce, content, design, and trust.

08 / What runs under the hood

Modern, boring, multi-tenant.

Every piece of the stack is something a Bangladeshi DevOps engineer can hire for and a regulator can audit. No managed-only lock-in.

  • Backend
    .NET 10, ASP.NET Core, MassTransit, MediatR, Hangfire
  • Frontend
    Next.js 16, React 19, TypeScript 5.9, Tailwind 4
  • Data
    PostgreSQL 18, RLS tenant isolation, Redis 8
  • Messaging
    RabbitMQ 4.2, event-sourced trust pipeline
  • Storage
    MinIO S3-compatible, imgproxy on-the-fly transforms
  • Edge
    Traefik + Cloudflare, wildcard SSL, custom-domain attach
09 / Frequently asked

Questions sellers ask before they migrate.

Each answer mirrors the on-page text in the structured-data payload, so AI answer engines and procurement reviewers see the same wording.

01What is Loom?
Loom is KaritKarma's multi-tenant website builder and commerce operating system. It pairs a visual Studio with 230+ live elements, a headless Scribe CMS, a B2B supplier catalog that feeds B2C seller stores, and an event-based trust scoring service. Sellers attach a domain through Wenme passkey sign-in, design pages in Studio with the same Section / Row / Column hierarchy that Elementor users already know, pull product truth from the supplier catalog, and route payments through LoneSock Pay. The platform is .NET 10 backend, Next.js 16 frontend, Postgres 18 with row-level security for tenant isolation, packaged as Docker Swarm services behind Traefik.
02How does Loom compare to Sanity, Contentful, and Strapi?
Sanity, Contentful, and Strapi are headless CMSes only. Loom ships Scribe (a headless CMS comparable to those three, with content types, GraphQL + REST, localization, preview tokens, scheduled publishing) and pairs it with a visual Studio, a commerce engine, multi-tenancy, and a trust layer in the same product. If you only need a CMS, Sanity is excellent and we say so. If you need a CMS plus a storefront plus a designer-friendly canvas plus B2B-to-B2C distribution, Loom is the only single-vendor option in this category in Bangladesh.
03How does Loom compare to WordPress + WooCommerce?
WordPress + WooCommerce is the platform most Bangladeshi sellers migrate from. Loom intentionally mirrors its Section / Row / Column page-builder UX so the muscle memory transfers, but replaces the plugin chaos with a curated module system, removes the security-patch treadmill by running multi-tenant SaaS, and adds two things WordPress cannot: a shared B2B catalog every seller can reference instead of re-keying SKUs, and a cross-store trust score that travels with the customer. CSV importers from WooCommerce, Shopify, OpenCart, and ZenCart are on the platform roadmap (Phase 6.2-6.3).
04Can Loom render at the edge?
Storefront pages are served by Next.js 16 with ISR (incremental static regeneration), which fronts every store with a sub-500 ms cold-page target and millisecond-range warm pages. Traefik terminates SSL at the platform edge with Cloudflare for SaaS handling custom-domain SSL provisioning. The .NET 10 API is the dynamic origin for cart, checkout, and storefront APIs. Static page chrome (theme, navigation, hero, product grids on category pages) is cached and revalidated against Scribe and Loom API events, so no shopper ever waits for a cold database round-trip on a chrome render.
05Can I import from WordPress or Shopify?
WordPress + WooCommerce, Shopify, OpenCart, and osCommerce / ZenCart are the four migration paths in the platform roadmap (Phase 6.2 and 6.3). The Loom team has identified these as the dominant migration sources for Bangladeshi sellers and is treating one-click importers as a launch-gating capability. Pages get translated to Studio Section / Row / Column trees, products are mapped against the supplier catalog where matches exist, and order history imports as historical-only records that the trust score does not double-count.
06How does multi-tenancy work, and is data really isolated?
Every tenant-scoped table includes a tenant_id column and is protected by PostgreSQL row-level security policies, so cross-tenant queries are impossible at the database layer, not just at the API layer. The API middleware injects tenant context from either the JWT or a domain-to-tenant lookup cached in Redis. Storefronts resolve to a tenant by custom domain (Cloudflare proxy mode through Traefik to the Storefront app) or by subdomain pattern slug.loom.bd. Studio, Admin, Scribe Admin, and the Platform console all run on the same RLS-guarded core, so an operator cannot accidentally read another tenant's pages or orders.
Ship the next store

One canvas for
content and commerce.

Loom is live at loom.bd. Pair it with Wenme, Darwan, BitsPath, and LoneSock Pay from the KaritKarma platform. One vendor, one deploy, one tenant model, six site verticals.