Ordertime is a thin orchestration layer with a set of well-defined adapter contracts. Everything else (your catalog, your money, your code, your customers) lives where it already does. We don't try to own the whole stack.
┌─────────────────────────────┐ ┌───────────────────────────┐ ┌──────────────────────────────┐
│ CATALOG SOURCE │ │ DATA STORE │ │ AI PROVIDER │
│ (merchant brings) │ │ (typed schema, locales) │ │ (OpenRouter / local / etc.) │
│ │ │ │ │ │
│ Shopify · Squidex │───▶│ Squidex · Sanity │◀──▶│ OpenRouter · Ollama │
│ Sanity · Contentful │ │ Contentful · Strapi │ │ Anthropic · OpenAI │
│ Zencart · Woo · JSON │ │ Hygraph · Payload │ │ LM Studio · self-hosted │
└─────────────────────────────┘ └───────────────────────────┘ └──────────────────────────────┘
│ │
▼ ▼
┌────────────────────────────────────────────────────┐
│ BUILD (runs in MERCHANT'S CI) │
│ │
│ @storefront/cli pulls catalog, runs AI features, │
│ emits normalized JSON + search index + structured │
│ data, hands off to the SSG adapter. │
└────────────────────────────────────────────────────┘
│
▼
┌────────────────────────────────────────────────────┐
│ SSG (Astro · Next · SvelteKit · 11ty · Hugo) │
│ renders static pages + assets │
└────────────────────────────────────────────────────┘
│
▼
┌────────┐
│ CDN │ ◀── public traffic, sub-100ms
└────────┘
│
▼
┌───────────────────────────────────────────────────┐
│ CHECKOUT (server-island OR pure JS) │
│ Cart → POST /v1/checkout │
└───────────────────────────────────────────────────┘
│
▼
┌───────────────────────────────────────────────────┐
│ ORDERTIME SERVICE (us, small and stateless-ish) │
│ · creates payment intent via processor adapter │
│ · saves order in 'pending', auth-hold only │
│ · returns clientSecret to checkout │
│ · capture happens later, after manual approval │
└───────────────────────────────────────────────────┘
│ │
▼ ▼
┌──────────────────┐ ┌────────────────────┐
│ PROCESSOR │ │ ORDERS DB │
│ Stripe · Paddle │ │ (pseudonymous) │
│ Mollie · etc. │ │ │
│ │ │ state machine: │
│ ◀── customer ──▶│ │ pending → │
│ pays here │ │ processing → │
│ │ │ confirmed → │
│ ──── webhook ──▶│ │ fulfilled │
│ │ └────────────────────┘
│ PII + cards │ │
│ live HERE, │ ▼
│ not with us │ ┌────────────────────┐
└──────────────────┘ │ DASHBOARD │
│ Squidex-based UI │
│ for orders + │
│ analytics + │
│ fulfillment │
└────────────────────┘
Three things are worth noticing. The build runs in your CI, not ours, because we don't operate a build farm. PII and cards stay at the processor, and we never see them. And every box marked "merchant brings" or "merchant's CI" is something you can swap or take with you.
Every part of your stack you would want to vary is its own adapter dimension. Add a Shopify connector without touching your SSG. Switch from Stripe to a high-risk processor without touching your catalog. Swap Astro for Next without rewriting your data layer. Adapters are commodity; your stack is yours.
Shopify, Zencart, WooCommerce, BigCommerce, JSON in your repo, or anything else that holds typed catalog data. We pull at build time.
Squidex, Sanity, Contentful, Strapi, Hygraph, Payload, Directus. Must support typed schemas, localization, scale, CLI, and webhooks. Five gates, no compromises.
Source webhook, data store webhook, GitLab/GitHub CI on push, cron, manual button, or programmatic API. You can combine multiple, with webhooks for freshness and cron as a safety net.
Astro, Next.js, SvelteKit, 11ty, Hugo. The build adapter exposes catalog data in your SSG's idiomatic API. Templates are yours.
Stripe, Paddle, Mollie, or specialty processors for high-risk verticals. We never sit between you and your money. Cards never touch us.
Server island (Astro, Next, SvelteKit, Nuxt) for fast cookie-backed cart. Pure JS fallback for true-static (Hugo, 11ty, plain HTML).
OpenRouter (recommended), OpenAI, Anthropic, Ollama, LM Studio, or any OpenAI-compatible endpoint. Used at build time for translation, SEO, and embeddings. Output is cached on source content hash, baked into static HTML, with no per-page-view LLM calls.
These aren't features we haven't gotten to. They are structural commitments that hold in both Basic and Managed. They protect the trust posture the architecture is built on.
Card numbers never touch our servers. Your processor handles payment. PCI scope on your storefront drops to SAQ-A.
Money flows directly between your customer and your processor's account. We never sit in the middle, and there are no payouts to schedule.
Your data is yours. We don't pool it, aggregate it, or sell it. The architecture has no cross-merchant data plane that could.
Your AI calls go through your provider key to your provider. We don't intercept, log, or train on prompts or outputs.
The architecture's bias is build-time, not runtime. Translation, SEO, alt-text, and embeddings are generated during the build, baked into static HTML, and cached on source content hash. A daily rebuild does almost no AI work because nothing has changed.
Runtime AI is reserved for features that genuinely need it (semantic search using pre-baked embeddings is the only obvious one). Generative chat per page view, dynamic personalization, and real-time AI inference are explicit non-goals.
for each product:
for each target locale:
source_hash = sha256(title + desc + locale)
if cache.has(store_id, "translate", source_hash):
use cached value ← typical case
else:
call AI provider ← only on change
cache.set(source_hash, result)
write into product.title.locales[locale]
# 5,000 products × 12 locales × 4 features
# = 240,000 derived field-values
# typically generated ONCE, then cached forever Ordertime is the catalog and orders layer for async commerce. Nothing more. Every line of the architecture is structured to keep that boundary tight, and to refuse the real-time premise that turns commerce platforms into operational disasters.
We don't run an app marketplace. We don't operate identity infrastructure for your customers. We don't calculate tax or shipping. We don't do subscriptions in Basic. We don't do real-time inventory. We don't auto-capture payments.
Each thing we don't do is either a complication that would slow us down and expand our liability, or a real-time fiction we refuse to maintain. The discipline of saying no, and being honest about which orders are real-time and which aren't, is the architecture's most important feature.