Platform Overview

Built on Salesforce Revenue Cloud

Quotonom is Salesforce Revenue Cloud under the hood — enterprise CPQ, pricing, and order management — delivered through a headless React SDK and a secure API proxy. Your UI, your rules, SF's power.

Architecture

Your App

@autonom/sdk

React hooks

Quotonom API

api.autonom.io

Proxy · Metering · Auth

Salesforce

Revenue Cloud

CPQ · Pricing · Orders

Typed hooks

Full TypeScript

API key auth

Per-tenant isolation

OAuth 2.0

To Salesforce

React SDK

Headless hooks, zero UI opinions

Five focused hooks cover every step of the CPQ journey. You own the markup, the styles, and the interaction model.

useConfigurator

Navigate product attribute trees, enforce constraint rules, get real-time pricing as options change.

usePricing

Fetch price schedules, apply discount tiers, compute totals with taxes and adjustments.

useCart

Manage line items, quantities, and bundles. Persist state across sessions automatically.

useCheckout

Submit quotes and orders back to Salesforce. Handle async approval flows and order status.

useCatalog

Browse and search the full product catalog with filtering, pagination, and real-time availability.

usePricebook

Switch price books per context (geography, segment, currency) without re-initializing.

app.tsx
import { AutonomProvider } from '@autonom/sdk';

export default function App() {
  return (
    <AutonomProvider apiKey="ak_live_..." tenantId="acme">
      <YourApp />
    </AutonomProvider>
  );
}
useConfigurator.tsx
import { useConfigurator } from '@autonom/sdk';

function ProductConfigurator({ productId }: { productId: string }) {
  const { structure, updateAttribute, pricing, isLoading } =
    useConfigurator(productId);

  if (isLoading) return <Spinner />;

  return (
    <div>
      <h2>{structure.name}</h2>
      {structure.attributes.map((attr) => (
        <AttributeSelector
          key={attr.id}
          attribute={attr}
          onChange={(val) => updateAttribute(attr.id, val)}
        />
      ))}
      <PriceSummary total={pricing.total} currency={pricing.currency} />
    </div>
  );
}
useCart.tsx
import { useCart, useCheckout } from '@autonom/sdk';

function CartView() {
  const { items, removeItem, total } = useCart();
  const { submit, isSubmitting } = useCheckout();

  return (
    <div>
      {items.map((item) => (
        <CartItem key={item.id} item={item} onRemove={removeItem} />
      ))}
      <p>Total: {total}</p>
      <button onClick={submit} disabled={isSubmitting}>
        {isSubmitting ? 'Processing...' : 'Place Order'}
      </button>
    </div>
  );
}
useCatalog.tsx
import { useCatalog } from '@autonom/sdk';

function ProductList() {
  const { products, isLoading, search } = useCatalog({
    category: 'software',
    limit: 20,
  });

  return (
    <div>
      <input onChange={(e) => search(e.target.value)} placeholder="Search..." />
      {products.map((product) => (
        <ProductCard key={product.id} product={product} />
      ))}
    </div>
  );
}
API Proxy

Multi-tenant, metered, secure

Quotonom sits between your frontend and Salesforce. We absorb auth complexity, enforce rate limits, and meter every call.

API key authentication

Issue scoped API keys to each of your customers or environments. Revoke instantly, set per-key rate limits.

Multi-tenant routing

Each tenant maps to its own Salesforce org. Requests are routed in isolation — zero cross-tenant bleed.

Usage metering

Every API call is counted and attributed. Integrate with Stripe for usage-based billing out of the box.

Rate limiting

Configurable rate limits per tenant, per key, per endpoint. Protects your Salesforce API quota automatically.

api-request.ts
// Authenticate with an API key
const response = await fetch('https://api.autonom.io/v1/products', {
  headers: {
    'Authorization': 'Bearer ak_live_...',
    'X-Tenant-ID': 'acme-corp',
  },
});

// Each request is metered and attributed to your tenant
const { products, usage } = await response.json();
// usage: { calls_remaining: 9847, reset_at: '2026-04-01T00:00:00Z' }

Request flow

1
Your AppSDK hook → HTTPS request + API key
2
Quotonom APIAuth · Metering · Rate limit · Cache
3
SalesforceRevenue Cloud REST API
Salesforce Revenue Cloud

Enterprise CPQ power, without the complexity

We don't rebuild pricing or product rules. We use Salesforce Revenue Cloud as-is — so you get enterprise-grade accuracy with none of the SF UI.

CPQ Engine

Constraint-based product configuration, discount schedules, approval workflows — all driven by your Salesforce rules.

Pricing Engine

Multi-dimensional pricing: list price, volume tiers, contracted rates, ramp schedules. SF computes, we deliver.

Product Catalog

Product families, bundles, features, options — full hierarchical catalog available via a clean REST interface.

Order Management

Submit orders, trigger fulfillment, track amendments and renewals through the Salesforce OMS lifecycle.

Why Salesforce Revenue Cloud?

Revenue Cloud is the market standard for enterprise CPQ — used by thousands of companies to manage complex product catalogs, pricing rules, and approval workflows. Quotonom lets you leverage all of that existing logic through a developer-friendly API, without forcing your customers through Salesforce's UI.

99.9%

SF uptime SLA

< 200ms

Median response

Zero

Rules reimplemented

Security

Enterprise security by default

Tenant isolation, encryption at rest, and zero-trust architecture — not bolt-ons.

AES-256 Encryption

All Salesforce OAuth tokens and credentials are encrypted at rest. Keys are rotated automatically.

Per-Tenant Isolation

Each tenant operates in a strict data silo. Zero cross-tenant access, enforced at the database and API layer.

API Key Auth

Scoped API keys with per-key rate limits and instant revocation. No OAuth complexity for your end users.

OAuth 2.0 to Salesforce

We handle the SF OAuth flow internally. Your customers never see Salesforce credentials or login pages.

tenant-record.json
// Tenant isolation — every secret is scoped
{
  tenant_id: "acme-corp",
  sf_access_token: "enc:v1:AES256:...",  // encrypted at rest
  sf_instance_url: "https://acme.my.salesforce.com",
  rate_limit: { rpm: 100, daily: 10000 },
  isolation: "strict"  // zero cross-tenant data access
}

Start building on Revenue Cloud today

10,000 free API calls to explore the full platform. No Salesforce expertise required.