Don't reinvent the physics.
Vibe-code the experience.
AI coding tools are genuinely powerful. The question isn't whether to use them — it's what to point them at. A commerce engine encodes decades of edge cases in inventory, payments, tax, promotions, and fulfillment. That's not where you want to improvise.
The smartest vibe-coders don't rebuild the engine. They build against one that already works.
This page compares vibe-coding your entire commerce stack from scratch with vibe-coding on top of Saleor's API. Same AI tools. Same speed. Very different outcomes at month 6.
We get it. The demo is incredible.
Production is different.
You open Claude Code or Codex, sketch a data model, prompt through a dozen services — catalog, cart, checkout, payment orchestration, inventory, orders — and a few weeks later you have a commerce API that compiles, passes its tests, and demos cleanly. It looks like senior-team work. It's roughly 81% faster than writing it by hand. We love this — we build with these tools every day.
The demo is real. The code runs, the API responds, the test suite is green. That's not the argument. The argument is what happens on day one of real traffic — and every day after.
of AI-generated e-commerce modules never make it to production
Nicolas Dabène, AI-Native E-commerce Architectfaster technical debt accumulation in AI-assisted codebases vs traditional development
ICSE 2026 meta-analysisof AI-generated code contains confirmed security vulnerabilities
Forrester research via WorthingtonOne you vibe-code.
One you don't.
The storefront is a verifiable, disposable, iterative artifact — AI coding tools genuinely shine there. That's where Paper, our AI-first storefront, lives. The commerce engine is a financial state machine where mistakes don't announce themselves: they leak data, lose money, or get you fined. Keep the line between them clean.
- Storefronts, PDPs, and landing pages
- Dashboards and admin extensions
- Third-party integrations (CRM, ERP, email, analytics)
- Agentic commerce entry points
- Marketing, campaign, and content pages
- Order lifecycle and state machine
- Inventory reservation, allocation, oversell guards
- Payment orchestration and PCI scope
- Tax calculation across jurisdictions
- Promotion stacking and precedence
- Auth, identity, and customer data
- Refund, fulfillment, and the financial ledger
The rule:vibe-code the layer where correctness is something you can see. The engine layer is where money is calculated, held, and moved — and those bugs don't announce themselves. They surface weeks later in reconciliation, chargebacks, or missing revenue, by which point they're expensive or impossible to undo.
Checkout flows, day one
Multi- or single-step checkout, payment orchestration, tax calculation, shipping rules — all handled by the API. Your AI agent builds the UX, not the financial state machine.
What happens after the demo?
AI gives you a checkout in hours. Partial payments, tax rounding on stacked discounts, abandoned cart recovery — each edge case is a new prompt, a new fix, a new thing that can break something else.
Inventory that's been tested at scale
Multi-warehouse allocation, stock reservations during checkout, backorder logic, and channel-specific availability — battle-tested across thousands of stores and hundreds of millions of orders.
Concurrency is a physics problem
Two customers, one item, same millisecond. Without reservation logic and atomic stock operations, you oversell. AI doesn't generate distributed-systems primitives from a product brief.
Promotions as a rules engine
Percentage, fixed, free shipping, buy-X-get-Y, tiered volume discounts — with deterministic stacking, redemption limits, and per-channel eligibility. Configuration, not code.
Promotions become if-statements
Stacking a percentage discount on a volume tier on a channel-specific coupon needs deterministic ordering. AI generates discount logic — but when an order total goes negative, nobody can trace which rule fired.
PCI compliance is not your problem
Saleor integrates with PCI-compliant payment providers. Tokenized payment flows, no card data touches your infrastructure. Compliance updates ship with platform releases.
Liability doesn't accept 'AI wrote it'
Payment patterns from training data may be stale or insecure. When the compliance audit comes, someone signs off with their name — not a prompt.
GraphQL schema = self-documenting API
AI coding agents introspect the full schema — every type, field, relationship, and mutation — in machine-readable format. They write correct queries on the first try.
Six months in, is your API still coherent?
No schema introspection, no enforced type safety, naming conventions that drifted with each session. The next AI agent — or the next developer — has to reverse-engineer what the last one meant.
160+ webhooks for any workflow
Order created, payment captured, fulfillment shipped, stock allocated — every commerce event is observable. Vibe-code your integrations against structured, documented events.
The happy path is the easy part
Refund-then-restock, partial fulfillment, split shipments — each workflow needs events you didn't emit. Integrations break silently on the gaps, and nobody truly understands how things are wired or how to coherently extend them.
Multi-channel from one instance
B2C, B2B, marketplace, regional stores — per-channel pricing, currency, tax, and language from a single backend. Adding a market is configuration.
The second market is the architecture test
One country, one currency, one tax regime — that was the demo. Adding B2B pricing, a second language, and EU VAT means forking or rewriting. Either way, the variants drift.
Open source — AI reads the engine
BSD-3 licensed. AI coding agents can read the actual commerce engine source code, not docs that might be stale. They verify behavior against real implementation.
Who holds the mental model?
It breaks at 2 AM on Black Friday. The AI that wrote it has no memory of the system. The prompts are scattered. Someone needs to understand the whole thing well enough to fix it. Who is that person?
Commerce has physics. These are some of them.
A product model and an order model aren't a commerce engine. The engine is the critical flows between them — and every edge case that only surfaces under load, across jurisdictions, or after the first refund.
Promotion stacking & precedence
When two promotions overlap, orders can go negative after tax and rounding. Deterministic precedence resolution is a financial requirement, not a feature.
Concurrency on limited redemptions
A coupon limited to 100 uses gets redeemed 137 times under load. Atomic counters, distributed locks, and race-condition-safe checkout are table stakes at scale.
Tax calculation across jurisdictions
US nexus rules, EU VAT MOSS, Brazilian ICMS, Canadian GST/HST/PST — each with different rules for digital goods, shipping, and discount application order.
Partial fulfillment & split shipments
Order of 5 items, 3 in stock at warehouse A, 2 backordered at warehouse B. Payment capture timing, inventory reservation, and customer communication all change.
Refund-then-restock workflows
Refund a line item, restock the inventory, recalculate the order total (promotions may now be invalid), issue a partial refund, update the financial ledger.
Payment orchestration
Gift card + credit card split payment. First payment fails mid-checkout. Rollback the gift card deduction, notify the customer, preserve the cart. Then add Klarna.
This is a partial list. Saleor's codebase encodes years of production learning across these flows.
Forrester sees the same thing
“
Commerce vendors will evolve into vibe coding platforms. They will provide APIs for capabilities, like PCI-compliant payments, that shouldn't be vibe coded. And they will provide coding agents that understand the commerce domain.
David Mooter, Principal Analyst at
“
There is a hard line between small process improvements or personal projects versus replacing major business applications like commerce solutions.
Emily Pfeiffer, Principal Analyst at
What vendors provide that code alone doesn't
Domain expertise
Decades of commerce edge cases encoded in the platform.
Best practices
Patterns proven across thousands of production stores.
Security & compliance
PCI, SOC 2, GDPR — maintained as regulations evolve.
Accountability
An engineering team on the other end when things break.
Perpetual improvement
The platform gets better every release. Your fork doesn't.
Who do you call?
Anthropic won't debug your checkout at 2 AM. OpenAI won't patch a security vulnerability in your payment flow. There's no SLA on a vibe-coded engine — no on-call team, no managed infrastructure, no one to call when Black Friday traffic hits.
Vibe-coded engine
You own every line — and every outage. No SLA. No on-call team. No security patches unless you write them. The maintenance burden grows with every feature, and the AI that generated it doesn't remember the context.
Saleor open source
20,000+ GitHub stars. Active community. Every behavior is traceable in source code. Security patches, performance improvements, and new features ship with every release — you upgrade, not rewrite.
Saleor Cloud
99.9% SLA-backed uptime. Managed infrastructure, automatic scaling, security patches applied for you. SOC 2 Type 2 certified. Engineering support from the team that built the engine — not a chatbot.
From the blog
Twelve months of ownership, side by side
Across senior engineering teams, the consensus is quiet and consistent: AI coding is excellent for code you can see fail, and unreliable for code that fails silently. Commerce engines fail silently. The table below is twelve months of that difference, side by side.
Free sandbox + a few weeks building your storefront UX against a commerce engine that's already production-grade.
A few weeks of prompting with Claude Opus or Codex and you have a working commerce API: catalog, cart, checkout, a payment integration, basic inventory, a database schema. It compiles. Tests pass. The demo feels real — because it is.
Both approaches feel fast, and at this stage they look indistinguishable — a working API, a working frontend, a demo you can click through. The gap opens later, when the first real edge case arrives.
Saleor Cloud plan. Dev time stays focused on conversion, UX, and new features. Infrastructure, security patching, and engine upgrades are handled for you.
Free tiers break the moment you have paying customers. Production infrastructure lands at ~$170–$350/mo (Vercel Pro + Supabase Pro + Clerk + Stripe + Sentry). Developer time inverts — 60% goes to maintenance, bug-hunting, and incident response on the parts you wrote yourself.
Inventory bugs, payment edge cases, and tax miscalculations start appearing. You're maintaining the engine instead of improving the experience.
Predictable Cloud cost. Zero engine maintenance. SLA-backed uptime. SOC 2 Type 2 is inherited from the platform. The API improves for free with every Saleor release.
$30,000–$100,000+ in Year 1 when you count what actually ships a commerce business: production infra ($6K–$32K), pen testing ($5K–$15K), comprehensive security audit ($10K–$30K), SOC 2 Type I if you sell B2B ($20K–$60K), and refactoring the vibe-coded core to production-grade ($12K–$24K). For a system nobody on your team fully understands.
Your competitors who used Saleor shipped three new features while you were writing security patches for your inventory system — and paying an auditor to approve them.
Upgrade to the next Saleor version. Your customizations are decoupled from the engine. SLA and support continue.
Rewrite or replatform. The code the AI wrote is now load-bearing infrastructure — with no SLA, no vendor support, no upgrade path, and nobody left who remembers why any of it was written the way it was.
67% of failed software implementations stem from incorrect build-vs-buy decisions.
What you should vibe-code
AI coding tools are a multiplier. Point them at the layer where speed matters most and correctness is verifiable — the experience layer. Let the commerce engine handle the physics.
Storefronts & landing pages
AI agents build beautiful, conversion-optimized frontends against Saleor's GraphQL API. Type-safe queries, introspectable schema, correct from the first prompt.
Custom workflows & integrations
ERP sync, CRM integration, marketing automation, custom fulfillment logic — vibe-coded against Saleor's 160+ webhooks. The events are structured; the integration is yours.
Dashboard extensions
45+ mount points in the Saleor Dashboard. Build custom admin views with any frontend stack. AI agents that understand the admin bridge ship with the platform.
Multi-channel experiences
Mobile app, kiosk, marketplace connector, AI shopping agent — each is a different frontend against the same API. Vibe-code each one independently.
Commerce as Code configuration
Define channels, product types, shipping zones, and tax rules in version-controlled YAML. AI agents read, modify, and deploy configuration through the Saleor Configurator.
Agentic commerce entry points
Build ACP-compatible endpoints so AI buying agents can browse, compare, and purchase from your store. The commerce engine handles transactions; you handle the interface.
Your vibe-coding toolkit
Paper
AI-first storefront foundation. Production-ready with Core Web Vitals, checkout, cart, and PDP built in. Point your AI coding tool at Paper and build a storefront in an afternoon — not an architecture.
Agent Skills
Skills that teach AI how your commerce works. Domain modeling, storefront patterns, API conventions — shipped as code your agent reads before it writes a single line.
Configurator
Commerce as code. Define channels, product types, shipping zones, and tax rules in version-controlled YAML. AI agents read, modify, and deploy configuration through a CLI.
Apps — GraphQL in, webhooks out. Build extensions in an isolated, self-describing environment. Release independently without breaking the platform.
When vibe-coding from scratch makes sense
We're not saying it never works. There are legitimate cases.
One-off promo stores
Temporary campaign landing pages with a simple cart and Stripe Checkout. Ship it, run the campaign, shut it down. No long-term maintenance burden.
Internal prototypes
Proof-of-concept for a business case. You're testing demand, not building infrastructure. The prototype is explicitly disposable.
Extremely narrow scope
Selling one product type, one market, one currency, no promotions, no inventory complexity. If your commerce logic fits in 200 lines, you might not need an engine.
For everything else — when you have real inventory, real customers, real compliance requirements, or plans to grow beyond one market — the commerce engine is the one thing that shouldn't be improvised.
Vibe-code on Saleor in 30 minutes
Get a free cloud sandbox, point your AI coding tool at the GraphQL API, and build something real. The fastest way to see the difference is to try both approaches.
Your competitors are building on solid foundations
Don't get passed while you're building better wheels. Use the best AI coding tools to build the best experience — on infrastructure that's already production-ready.