Vectis — B2B & B2C Commerce Platform

Origin

Why we built Vectis.

We tried the other commerce platforms. Open-source frameworks and the big hosted SaaS names alike. Each one picks a lane. B2C platforms treat wholesale as a plugin afterthought. B2B platforms strip out the merchandising, promotions, and storefront polish that retail needs. Nobody runs both with the same confidence.

Multi-location accounts, tiered pricing, net terms, approval workflows — in most platforms these are bolted on, not modeled. Promotions? A weak coupon system at best. Shipping? Duplicated carrier configs with no concept of the box itself. Extensibility? Usually a handful of webhooks with no real access to the internals that matter.

Performance is the other half of the problem. ORMs generating N+1 queries. No caching strategy for expensive operations like multi-tier pricing resolution. Systems that crumble under the catalog sizes and pricing complexity real businesses actually run.

So we stopped patching and started building. In Vectis, both B2B and B2C are first-class citizens of the core data model. Every module — accounts, pricing, promotions, fulfillment, order flow — is designed to serve wholesale and retail side by side. Channels let each audience have its own rules, pricing, visibility, and checkout, all on one engine, one catalog, one API. Hosted or on-prem, with every feature included from day one.

The problem

Platforms pick a lane. B2B or B2C — one side always suffers.

The reality

Duct-taped data models, weak promotions, shipping built backwards, brittle extensibility.

The answer

B2B & B2C both at the core. Serious promotions. Boxing-first shipping. Every feature, every tier.

Philip N. Deatherage

Founder

From the Founder

Vectis isn't a first project. It's the product of 30 years of building, running, and scaling e-commerce businesses — from the warehouse floor to the architecture whiteboard. Wholesale, distribution, multi-channel retail. The patterns that work, the mistakes that don't, and the frustration of watching platforms ignore the complexity that B2B actually demands.

That experience is in every decision. Why the pricing engine has five tiers instead of one. Why net terms and approval workflows are core modules, not plugins. Why the order state machine is configurable — because every business has a different flow and no platform should dictate yours. Why the admin panel puts the information operators actually need front and center, not buried three clicks deep.

Vectis is built by someone who's lived the problem. The goal isn't just a technically sound platform — it's one that's intuitive for the people who use it every day: warehouse managers, sales reps, buyers placing 500-line orders at 6am. If it doesn't make their job easier, it doesn't ship.

Platform

Everything, in the core.

Wholesale needs. Retail needs. All of it, in the box — no paywalls, no plugins-that-should-have-been-core.

5-Level Pricing Engine

Global base, customer-group, account, location, and contract pricing with volume tiers. Redis-cached resolution. The feature every B2B platform gets wrong — Vectis gets right.

Dual-Core Accounts

B2B accounts with multiple locations, employees, addresses, and customer groups — right next to individual B2C customers in the same data model. Per-location carts, pricing, and catalog visibility for wholesale. Fast guest checkout and individual accounts for retail.

Strategy Architecture

Pricing, tax, shipping, inventory, and order flow all run through swappable strategies. Replace any business rule without forking core. This is what real extensibility looks like.

Approval Workflows

Temporal-powered durable workflows for order approvals, PO review, and compliance gates. Survives crashes and restarts without losing state. Try doing that with a webhook.

Net Terms & Invoicing

Net-15, Net-30, Net-60 payment terms per account. Automated invoice generation, store credit ledger, and payment tracking. Core module, not an aftermarket addon.

Payment Lifecycle

Auth-then-capture, saved cards (CIM), fraud hold states, auto void/refund on cancel. Authorize.net, NMI, ACH, and manual payments built in. Location-scoped card storage for B2B. One-click checkout with Accept.js tokenization.

Boxing-First Fulfillment

3D bin packing engine calculates optimal box assignments. Product dimensions, carrier limits, and method-specific box restrictions — all resolved automatically. Split shipping for restricted items. 7 carrier extensions with channel-scoped zones.

RBAC, 2FA & Social Login

Granular role-based permissions for admin staff. TOTP and email/SMS two-factor auth. Google/OAuth social login for storefront buyers. Keycloak SSO extension for enterprise identity.

AI-Powered Editing

TipTap rich text editor with AI action toolbar — improve, shorten, expand, fix grammar, translate, change tone. Claude, ChatGPT, and OpenAI extensions. Admin-configurable prompt templates per category.

Multi-Strategy Tax Engine

Sales tax with cascading jurisdiction match down to city level. Vanilla excise tax in core (per-unit or percentage). Extension slots for TaxJar, Avalara, and ExciseIQ. Short-circuit evaluation skips exempt accounts and taxless channels before touching the pipeline.

B2B Registration System

Drag-and-drop form builder with geo-conditional rules. Document upload with AI/OCR verification. E-signature capture via DocuSign or HelloSign. Invitation codes. Temporal-driven approval workflows. Built for wholesale onboarding.

Geolocation & File Storage

IP geolocation via MaxMind (auto-detect locale, currency, region). Address validation at checkout. ISO 3166 geo data seeded. Pluggable file storage — local, S3, MinIO, or DigitalOcean Spaces via strategy extensions.

Fraud Detection Engine

Built-in rules engine with velocity checks, blocklist matching, AVS/CVV auto-hold, and IP geolocation distance. Signifyd, Riskified, and IPQS extensions for enterprise-grade scoring. Admin fraud review queue with approve/decline workflows.

See it in action

A real admin. Built for operators.

Every screen below is shipping UI from the Vectis admin — not mockups. Built on SvelteKit 2 + Svelte 5 + Houdini, with a keyboard-first workflow and a command palette on every page.

Keyboard-first

Spacebar is your command palette.

Jump to any order, customer, product, or page in two keystrokes. Fuzzy-matched across every entity in the system, with scoped shortcuts per module.

Operations

Live dashboards. Risk-scored orders.

Real-time order volume, revenue, and inventory signals. Every order ships with fraud risk, AVS/CVV checks, IP geolocation distance, and a reviewable evidence trail.

Operations dashboard

Revenue, orders, customers, and inventory health in one glance.

Orders list

Filter, segment, and bulk-act on orders across every channel.

Risk assessment per order

Built-in velocity, blocklist, AVS/CVV, and geo-distance scoring.

Catalog & Accounts

Multi-account. Multi-variant. Multi-channel.

Accounts with locations and employees. Products with unlimited variants, tiered pricing, and per-channel visibility. One catalog, every selling model.

B2B accounts

Multi-tenant with locations, employees, and rep assignment.

Products

Unified catalog across B2B and B2C with visibility rules.

Variants & pricing tiers

5-level volume breaks, case packs, MOQ, per-channel price.

Promotions Engine

One of the most powerful in commerce.

25+ condition types, 8 action types, stacking policies, priority, usage caps, mutually-exclusive rule lists, and bulk coupon generation — all evaluated in O(1) per cart via a prebuilt CartIndex.

Visual promotion editor

Build any deal without SQL, scripts, or deploy cycles.

Cart conditions

Subtotal, item count, weight, SKU match, category, collection.

Customer conditions

Group, tier, lifetime value, order count, region, channel.

Actions

% off, fixed amount, BOGO, free shipping, gift, tier upgrade.

Usage limits

Per-customer, per-account, per-location, per-group, daily caps.

Stacking & priority

Mutually-exclusive lists, coupon-only stacking, max-in-cart.

Bulk coupon generation

Templated formats, thousands of codes at once, export-ready.

Trust & Compliance

Fraud caught. Compliance enforced.

A rules engine for fraud signals and regulatory gates — age verification, restricted shipping, PACT Act, state-by-state flavor bans. Signifyd, Riskified, and IPQS extensions available.

Fraud review queue

Risk-scored orders with approve/decline workflows.

Fraud rules

Velocity, blocklist, AVS/CVV auto-hold, geo-distance.

Compliance rules

Age gates, PACT Act, restricted SKUs by ship-to jurisdiction.

Content & Branding

A CMS. A theme system. An AI writer.

Build landing pages, swap themes, and generate product copy without leaving the admin. Brand-consistent AI content generation is first-class — not an afterthought.

CMS pages

Flexible landing pages, blocks, and versioned drafts.

Themes

Swap storefront themes per channel without a redeploy.

AI content generation

Product copy, SEO metadata, and blog drafts on demand.

Commerce Operations

The day-to-day, sorted.

Gift cards, checkout agreements, self-service account management for B2B buyers, and a reports module purpose-built for wholesale and retail together.

Gift cards

Issue, redeem, and reconcile store credit.

Checkout agreements

Terms, age-gate, and per-jurisdiction acknowledgements.

Account management

Self-service for B2B buyers: locations, employees, roles.

Reports

Revenue, AOV, cohort, and promo attribution by channel.

Platform & Extensions

Extend it. Don't fork it.

First-class extension points for tax, fulfillment, payments, ERP, fraud, and file storage. Install, configure, toggle — no patching the core.

Settings

Channels, currencies, tax, shipping, auth — unified config.

Extension marketplace

Install and toggle first-party and third-party integrations.

Tax providers

Avalara, TaxJar, or roll your own — swap via strategy.

Channels

One platform. Every selling model.

B2B and B2C are both first-class in Vectis. Channels let you serve wholesale and retail buyers from a single catalog, a single order engine, and a single API — with pricing, visibility, checkout flow, and account model that adapt per channel.

B2B Channel

Wholesale · Distribution · Trade

✓ Multi-tenant accounts with locations & employees
✓ 5-level tiered pricing with volume breaks
✓ Net terms, PO numbers, approval workflows
✓ Catalog visibility rules per account
✓ Minimum order quantities & case packs
✓ Login walls, gated pricing, rep assignment

B2C Channel

Retail · DTC · Consumer

✓ Individual customer accounts
✓ Standard retail pricing & promotions
✓ Credit card checkout, no net terms
✓ Public catalog, open browsing
✓ Single-unit ordering, no MOQ
✓ Guest checkout, simplified flows

How channels work

1

Same product catalog, same inventory, same order engine under the hood.

2

Each channel defines its own pricing rules, checkout flow, visibility, and account model.

3

Storefronts connect to a channel. The API adapts behavior automatically.

Promotions Engine

One of the most powerful
promotions engines in commerce.

A real rules engine, not a coupon codes table. Compose any promotion you can imagine from composable conditions and actions — with stacking policies, caps, priorities, and per-channel rules baked in.

8 Action Types

Percentage off, fixed amount, fixed per line, volume-tiered percentage, bundle discount, free gift, buy-X-get-Y (BOGO and beyond), free shipping. Each action is composable with the others.

25+ Condition Types

Cart min/max totals, item count thresholds, customer groups, categories, collections, brands, traits, first-order, channel, account, location, country, role, day-of-week, time-of-day, seasonal windows, blackout dates.

Stacking & Priority

Stackable, exclusive, or coupon-only stacking. Mutually-exclusive rule lists. Max simultaneous in cart. Priority ordering. Auto-apply vs. coupon-code entry. The engine picks the best combo for the buyer every time.

Usage Limits & Caps

Total redemption limit. Per-customer limit. Single-use codes. Daily caps. Max discount amount per rule. Once-per-order enforcement. Email whitelists. Staff-only and role-visible rules for sales reps.

Sub-millisecond Evaluation

Pre-built CartIndex in a single O(n) pass, then O(1) condition checks. Thousands of active rules evaluated per cart update without breaking a sweat.

Per-Channel, Per-Tier

Run retail coupons on the B2C channel, volume-tiered wholesale rebates on the B2B channel — from the same rule engine. Conditions route naturally by channel, account, or customer group.

rule · volume_tiered_wholesale

{
  "name": "Wholesale volume tiers — Vape category",
  "type": "automatic",
  "stacking_policy": "coupon_only",
  "priority": 100,
  "conditions": [
    { "type": "channel",
      "config": { "channel_codes": ["b2b"] } },
    { "type": "product_in_category",
      "config": { "category_ids": [42] } },
    { "type": "customer_in_group",
      "config": { "group_ids": [7, 8] } }
  ],
  "actions": [
    { "type": "volume_tiered_percentage",
      "config": { "tiers": [
        { "min_qty": 12,  "percent": 5  },
        { "min_qty": 48,  "percent": 10 },
        { "min_qty": 144, "percent": 15 }
      ] } }
  ]
}

admin · rule builder

Wholesale volume tiers

Automatic · Active · Priority 100

Running

When

channelisb2b

categoryisVape

customer_groupinTier 1, Tier 2

Then

volume_tiered_percentage

12+

5%

48+

10%

144+

15%

1,248

Redemptions

$42k

Dispensed

+18%

AOV lift

Shipping, Rethought

E-commerce thinks about shipping backwards.

Every other platform starts with carriers. Pick a carrier, configure zones, assign rates, and then hope the box fits. You end up duplicating box configurations across every carrier and zone combination. Change a box size? Update it everywhere.

Vectis starts with the box. Define your box templates once — with inner dimensions, tare weight, and max capacity. Assign boxes to providers or methods. Then a 3D bin packing engine packs every order into the optimal set of boxes automatically. Those packed boxes are then handed to whichever carrier and method the zone selects.

Boxes are the universal constant. Carriers are interchangeable. Zones just filter which methods show up for an address. No more configuring the same box for UPS and then again for FedEx and then again for USPS. Define it once, assign it to a provider, and every method under that provider uses it.

How Vectis shipping works

1

Pack

3D bin packing engine fits items into eligible box templates. Inner dims, weight limits, fragile/priority handling.

2

Assign

Packed boxes inherit their carrier and method from box-to-provider or box-to-method assignments. One box template, many carriers.

3

Quote

Each packed box becomes a Package with real dimensions and weight. Carrier strategies quote rates per box. Flat-rate methods multiply by box count.

4

Ship

Each box gets its own tracking, carrier, and label. Ship by-box for warehouse precision or by-order for simpler operations.

From cart to carrier

Define a box once. Use it everywhere.

A box template lives at the center. Assign it to UPS, FedEx, and USPS — one config, three carriers. When an order is placed, the 3D packing engine chooses which boxes to use, the zone picks the method, and each packed box carries real dimensions to the carrier for a rate.

Small

8×6×4

Medium

12×10×6

Large

18×14×10

3D Packing Engine

EB-AFIT algorithm, multi-bin, gravity, load-bearing, fragile handling

Box Templates

Define once, assign to providers/methods. Inner dims, tare weight, material cost.

8 Carriers + AfterShip

UPS, FedEx, USPS, GoShippo, ShipStation, OnTrac, Priority1. AfterShip tracking.

Split Shipping

Restricted products auto-split into separate shipments by method.

Tech Stack

Every choice has a reason.

No framework roulette. Each layer was chosen for what B2B commerce actually demands at scale — performance, async I/O, type safety, and real extensibility.

FastAPI

Backend framework

Async from the ground up. Native Pydantic validation on every request. Auto-generated OpenAPI docs in dev. FastAPI handles thousands of concurrent connections without breaking a sweat — critical when your storefront, admin panel, and integrations are all hitting the same API.

Why not Django/Flask: synchronous by default. Retrofitting async onto a sync framework is duct tape.

Strawberry GraphQL

API layer

Type-safe Python-first GraphQL. The schema is composed from domain modules — each module registers its own queries and mutations. Storefronts fetch exactly the data they need in one round trip. No over-fetching, no REST endpoint sprawl.

Why not REST: B2B frontends need flexible data shapes. A product page with pricing tiers, inventory per warehouse, and account-specific visibility is one query, not five.

PostgreSQL 16

Transactional data

The database that doesn't surprise you at 3am. ACID transactions, JSONB for flexible metadata, row-level security, and partitioning for large catalogs. SQLAlchemy 2.0 async with Alembic migrations — the ORM that gets out of the way.

Why not MongoDB: B2B pricing is relational. Five pricing tiers referencing accounts, locations, and customer groups is a JOIN problem, not a document problem.

SvelteKit

Admin & Storefront

Both the admin panel and the buyer-facing storefronts are SvelteKit apps. Server-side rendering for SEO, BFF pattern with httpOnly cookies for security, Svelte 5 reactivity, Paraglide JS for type-safe i18n, LayerChart for visual dashboards, TanStack Virtual for 1000+ row tables. Tailwind CSS 4.

Why not Next.js/React: smaller bundles, less boilerplate, faster renders. Paraglide's compile-time i18n means zero runtime overhead for translations.

Temporal

Durable workflows

Order approval chains, recurring order scheduling, and multi-step fulfillment flows that survive crashes, restarts, and deployments. Workflows are code, not YAML — version them, test them, debug them like any other module.

All workflows and background tasks unified under Temporal — durable business processes and scheduled jobs through a single system with full visibility.

Redpanda

Event streaming

Kafka-compatible but without the JVM tax. When an order is placed, inventory, notifications, fulfillment, and analytics all react in parallel through event topics. Decoupled modules, no cascading failures, full replay capability.

Why not RabbitMQ: topic-based fan-out, persistent log, replay from any offset. Event sourcing needs a log, not a queue.

Redis

Cache & sessions

Pricing resolution is the most expensive operation in B2B — five tiers with volume breaks, evaluated per line item. Redis caches resolved prices so the second request for the same account + product is sub-millisecond. Also backs BFF sessions.

Typesense + Meilisearch

Dual search engines

Typesense powers storefront product search with scoped API keys for catalog visibility. Meilisearch handles admin search. Both are typo-tolerant, faceted, and sub-50ms. No Elasticsearch cluster to babysit.

Why dual: storefront search needs scoped keys per buyer. Admin search needs full access. Different security models, different engines.

Architecture

Modular monolith.
Event-driven core.

38 domain modules behind a single GraphQL endpoint. Clean service boundaries internally, zero microservice overhead externally.

GraphQL API

Strawberry GraphQL with async resolvers. Type-safe schema composed from 38 domain modules. One endpoint, full B2B and B2C surface area.

POST /graphql

GET /health

Data & Cache

PostgreSQL 16 for transactional data. Redis for session cache and pricing resolution. Typesense + Meilisearch for search. MinIO (S3-compatible) for file and media storage.

SQLAlchemy 2.0 async

Alembic migrations

Pydantic v2 schemas

Events & Workflows

Redpanda (Kafka-compatible) for event streaming via a dedicated consumer process. Temporal worker for durable workflows like approvals and recurring orders. In-process event bus for module communication.

order.placed → inventory

order.placed → notifications

order.placed → fulfillment

Clients

Admin SvelteKit :5173

B2B Storefront SvelteKit :5174

B2C Storefront SvelteKit / any

BFF · httpOnly cookies · Channel-aware

Channel Router

Routes requests to the correct channel · Applies pricing, visibility, and checkout rules per channel

GraphQL API :8000

FastAPI + Strawberry · 36 domain modules · Strategy pattern

PostgreSQL

Redis

Redpanda

Temporal

Typesense

Meilisearch

MinIO (S3)

Geo (ISO 3166)

Modules

38 domains. One codebase.

Every module is self-contained with its own models, services, resolvers, and events. Clean boundaries enforced by convention — no cross-module SQL.

AccountsMulti-tenant, locations, employees

ProductsVariants, brands, categories

Pricing5-level tiers, volume breaks

OrdersConfigurable state machine

CartPer-location, snapshots

InventoryMulti-warehouse stock

FulfillmentBoxing first, carrier strategies

PaymentsAuth/capture, saved cards, fraud

TaxSales + excise, multi-strategy

Promotions25+ conditions, 8 actions, stacking

ApprovalsTemporal-powered workflows

Net TermsNet-30/60, invoicing

QuotesRFQ with Temporal lifecycle

RMA / ReturnsLine-level, approval gates

Sales RepsTerritories, pipeline

Store CreditLedger-based balance

SearchTypesense + Meilisearch, scoped

CMSPages, blocks, navigation

TagsFlexible entity tagging

NotificationsEmail, SMS, in-app

ReportingLayerChart dashboards, exports

Recurring OrdersScheduled reorders

Catalog VisibilityPer-account product access

Audit TrailFull change history

AuthRBAC, 2FA, social OAuth

MarketingCampaigns, abandoned carts, email

Gift CardsBalance, redemption, ledger

ComplianceAge, tobacco, restricted SKUs

Support ChatIn-app messaging, sales rep

PlatformChannels, storefronts, branding

TrackingAfterShip events, status pings

BannersStorefront announcements, promos

FraudRules, blocklist, review queue

ActivityCustomer and system events

AIRich text editor, AI prompts

FeesPackage protection, surcharges

RegistrationForm builder, approval workflows

i18nParaglide JS, compile-time

Geo (ISO)Countries, regions, counties

GeolocationIP lookup, geocoding, validation

ChannelsB2B + B2C, per-channel rules

ExtensionsEntry points, per-storefront

Extensible

Extend without forking.

Vectis uses Python entry points for a true plugin architecture. Add custom tax providers, carrier integrations, compliance checks, or entirely new modules without touching core code. Extensions are scoped per storefront — your B2B store can run tobacco compliance while your B2C store doesn't.

Per-Storefront Extensions

Extensions activate per storefront. Different storefronts get different capabilities — no global on/off switches.

Strategy Registration

Register pricing, tax, and shipping strategies via entry points. The core discovers them at boot.

Event Hooks

Subscribe to domain events (order.placed, account.created) to trigger custom workflows.

41 Bundled Extensions

Payment, shipping, AI providers, fraud scoring, e-signatures, address validation, file storage, marketing, age verification, SSO, package protection — all ship out of the box.

pyproject.toml

# 41 extensions — payment, shipping, AI, fraud, address, storage, and more
# Payment
authorize_net nmi ach manual_payment
# Shipping
ups fedex usps usps_flatrate goshippo
shipstation ontrac priority1 aftership
# Address validation
smarty shipstation_address google_maps
# AI
anthropic claude openai chatgpt grok
# Fraud & compliance
signifyd riskified ipqs radar
agechecker
# Storage
s3 minio digitalocean_spaces dropbox
# E-signatures
docusign hellosign
# Marketing & messaging
omnisend elastic_email ses sns twilio
# Auth, geo, tax, commerce
keycloak maxmind exciseiq gift_cards package_protection

We tried the alternatives.

Open-source frameworks and hosted SaaS giants — great for B2C. Here's where they stop.

Capability	Open-source / hosted SaaS	Vectis
Multi-location accounts	Not in data model	Core
Tiered B2B pricing	Plugin / manual	5-level, cached
Net terms & invoicing	Build it yourself	Core
Approval workflows	Not available	Temporal-powered
Swap pricing / tax / shipping logic	Fork the core	Strategy pattern
Catalog visibility per account	Plugin	Core
Event-driven architecture	Hooks / basic events	Redpanda + EventBus
Durable business workflows	Not available	Temporal
B2B + B2C from one engine	Pick one	Channels
Multi-strategy tax (sales + excise)	Single provider	resolve_all pipeline
ISO geographic data (seeded)	String fields	FK-based, ISO 3166
IP geolocation + address validation	Extension / paid only	Core (MaxMind free)
Fraud scoring (IP distance, VPN detection)	Not available	Async via Temporal
3D bin packing engine	Not available	Built-in + fallback
Auth/capture + auto void/refund	Basic charge only	Full lifecycle
RBAC + 2FA + social login	Basic roles	Granular + TOTP + OAuth
Age verification	Not available	AgeChecker.net
AI content editing	Not available	Claude, ChatGPT, OpenAI
B2B registration + e-signatures	Not available	Form builder + DocuSign
Pluggable file storage	Local only	S3, MinIO, DO Spaces
Composable promotions engine	Coupon codes only	25+ conditions · 8 actions
Volume-tiered B2B discounts	Not available	Native rule type
Stacking policy + mutually-exclusive rules	Manual / none	Built-in
Boxing-first shipping model	Duplicate box configs per carrier	Define once, assign to providers
Bundled extensions	3-5	41 and growing

Pricing

Hosted or on-prem. Your call.

Every plan includes the full platform — all 38 modules, all 41 extensions, every feature. No gated tiers. Pick how you want it deployed.

Hosted Starter

TBD

per month · managed cloud

✓ Full platform (38 modules, 41 extensions)
✓ B2B + B2C channels
✓ Multi-strategy tax + fraud engine
✓ 3D box packing + 8 carrier integrations
✓ RBAC, 2FA, social login
✓ Managed infrastructure + auto-updates
✓ Standard support

Coming Soon

Coming soon.

Vectis is in active development. The source will be available on GitHub when it's ready. When it lands, setup looks like this:

$ git clone <coming-soon> && cd vectis

$ make setup && make up

✓ Full B2B stack in under 5 minutes

GitHub — Coming Soon Read the Docs

Built for B2B. Built for B2C. Both at the core.

Why we built Vectis.

Everything, in the core.

5-Level Pricing Engine

Dual-Core Accounts

Strategy Architecture

Approval Workflows

Net Terms & Invoicing

Payment Lifecycle

Boxing-First Fulfillment

RBAC, 2FA & Social Login

AI-Powered Editing

Multi-Strategy Tax Engine

B2B Registration System

Geolocation & File Storage

Fraud Detection Engine

A real admin. Built for operators.

Spacebar is your command palette.

Live dashboards. Risk-scored orders.

Operations dashboard

Orders list

Risk assessment per order

Multi-account. Multi-variant. Multi-channel.

B2B accounts

Products

Variants & pricing tiers

One of the most powerful in commerce.

Visual promotion editor

Cart conditions

Customer conditions

Actions

Usage limits

Stacking & priority

Bulk coupon generation

Fraud caught. Compliance enforced.

Fraud review queue

Fraud rules

Compliance rules

A CMS. A theme system. An AI writer.

CMS pages

Themes

AI content generation

The day-to-day, sorted.

Gift cards

Checkout agreements

Account management

Reports

Extend it. Don't fork it.

Settings

Extension marketplace

Tax providers

One platform. Every selling model.

B2B Channel

B2C Channel

How channels work

One of the most powerful promotions engines in commerce.

8 Action Types

25+ Condition Types

Stacking & Priority

Usage Limits & Caps

Sub-millisecond Evaluation

Per-Channel, Per-Tier

E-commerce thinks about shipping backwards.

How Vectis shipping works

Define a box once. Use it everywhere.

Every choice has a reason.

FastAPI

Strawberry GraphQL

PostgreSQL 16

SvelteKit

Temporal

Redpanda

Redis

Typesense + Meilisearch

Modular monolith. Event-driven core.

GraphQL API

Data & Cache

Events & Workflows

38 domains. One codebase.

Extend without forking.

Built for B2B.
Built for B2C.
Both at the core.

One of the most powerful
promotions engines in commerce.

Modular monolith.
Event-driven core.