Pricing Architecture & Specs
A hyper-optimized calculation backend featuring a Wasm Edge Quoting Compiler, Priority Resolution Math, and Neural Bus Generative 3D integration.
System & Calculation Metrics
Quote Calculation Time
<10ms via WebAssembly
Offline Capabilities
Fully supported (Edge Wasm binary)
3D Render Delay
Sub-second asset mapping via WebXR
Cart Resolution
Sub-millisecond application-layer lookup against indexed price lists
1. Wasm Edge Quoting Engine
Legacy CPQ software relies on slow REST APIs to evaluate complex configuration rules. Aeion completely decentralizes this calculation. - The Wasm Compiler: When a pricing matrix (discounts, volume tiers, compatibility rules) is saved, Aeion compiles the rule logic directly into WebAssembly — producing a real, runnable binary ready to deploy to browsers, tablets, and edge devices, not just a preview. Server-side rule resolution is also GA. - Offline Edge Execution: the compiled binary runs anywhere WebAssembly runs — a sales rep's iPad, a PWA, or directly in the customer's browser — computing the quote locally in under 10ms, with no server round-trip needed.
typescript
// Example: Priority Resolution Math executing server-side for standard cart interactionsfunction resolvePrice(productId, customerSegments, baseRetailPrice) { // Look up every active price list matching this product + customer segment, // ordered by admin-defined priority const applicableLists = getApplicablePriceLists(productId, customerSegments);
// Evaluate each list's formula and keep the lowest valid price for the customerlet lowestPrice = baseRetailPrice;for (const list of applicableLists) {const calculated = evaluateRule(list.formula, baseRetailPrice);if (calculated < lowestPrice) lowestPrice = calculated;}
return lowestPrice;}2. Generative 3D CPQ Orchestration
Pricing rules often correlate to physical product variations. Aeion unites the mathematical logic with visual rendering natively.
- The Neural Bus Bridge: Aeion Pricing connects directly to the Spatial module via the Neural Bus. When a user selects a configuration option in the UI (e.g., "Add 1000W Engine"), the event is intercepted.
- Dynamic WebXR Rendering: The logic engine evaluates the Wasm constraints (e.g., "If 1000W Engine is selected, require Heavy Duty Chassis"). The Neural Bus instructs the Spatial engine to dynamically fetch the required 3D .glb assets and render the newly compiled holographic model via WebGL instantly in the user's viewport.
Maintaining multiple price lists across B2B channels can cause massive database bloat if poorly modeled. The Pricing module uses an overlay architecture — it never duplicates your product catalog. Price lists sit on top of your existing products and are matched in automatically during checkout, so your base product catalog stays a single, canonical source of truth.
Relying strictly on real-time exchange rates (e.g., USD to EUR) is dangerous for international businesses protecting their margins. The Pricing module allows for Explicit Currency Overrides. You can define a product as $100 USD, but hardcode it to €110 EUR for European customers. Aeion automatically identifies the customer's region and maps it directly to the explicitly defined price list, bypassing dynamic conversion APIs entirely.
Frequently Asked Questions
It's a real, runnable WebAssembly binary. When a pricing matrix — volume tiers, compatibility rules, discount logic — is saved, Aeion compiles that rule logic into a Wasm module that executes anywhere WebAssembly runs: a sales rep's iPad, a PWA, or the customer's browser. Server-side rule resolution is also GA for teams that prefer centralized calculation, so the same rules can run at the edge or on the server without a rewrite.
The compiled binary carries the rule logic with it, so the quote is computed locally — typically in under 10ms — even with no connectivity. This is what lets a rep build a 50-line wholesale quote on an iPad in the field without every line stalling on a network call back to a vendor's servers.
The Priority Resolution engine evaluates every active price list matching the product and customer segment, then returns the lowest valid price. Resolution runs natively inside PostgreSQL for standard cart interactions — there's no application-layer math to race against, so a customer with a VIP list and an active Black Friday promotion deterministically gets whichever is genuinely lower.
No — the engine uses an overlay architecture and never duplicates products. Price lists sit on top of your existing catalog and are matched in automatically at checkout, so your base catalog stays a single canonical source of truth no matter how many negotiated tiers you layer on.
Only if you want to. Explicit Currency Overrides let you hardcode a price per region — e.g., $100 USD but €110 EUR for European customers — and Aeion maps the customer's region straight to that defined price, bypassing fluctuating real-time conversion APIs entirely. That protects margin instead of exposing it to FX swings.
Configuration changes flow over the Neural Bus. When a customer selects an option, the event is intercepted, the logic engine evaluates the Wasm constraints (e.g., "1000W engine requires a heavy-duty chassis"), and the Neural Bus instructs the Spatial module to fetch the required `.glb` assets and render the updated model in WebXR — the visual and the price move from the same event, not two separate systems trying to agree.
See the Wasm quoting engine in action.
Sub-10ms edge quotes, PostgreSQL-native priority resolution, and Generative 3D CPQ — walk through the architecture with our team.