Every SaaS team running a sales-led motion has the same moment.
The quote is out. The order form is countersigned. Now someone has to turn it into a live customer: the pricing, the limits, the meters, the grace period, the invoice terms, the billing cadence. AE hands it to solutions. Solutions hands it to engineering. Finance flags an issue on the first invoice. A week later the customer is still asking when they can log in.
This is the missing piece of quote-to-cash. Every commercial stack has one.
It happens because in most SaaS stacks, a custom plan isn't a plan. It's a one-off configuration scattered across a code exception, a hand-built Stripe price, a feature flag wired by hand, a Salesforce note, a Notion doc. Nothing about it is reusable. Nothing about it is durable.
We shipped custom plans as a first-class object. Phase 1 runs on Stripe Billing.
A custom plan in Schematic is a standalone plan that belongs to one company. Its own pricing. Its own entitlements. Its own metered billing rates and billing terms. Grace periods, invoiced billing, usage-based overages, flat-rate components, whatever the order form specified.
The shape of the workflow:
Create the plan and attach it to the company. Set the pricing, limits, meters, and entitlements individually. Define the billing period, payment terms, and an optional grace period. Send a payment link, or let the customer pay by invoice. Then manage the rest of the customer's lifecycle from the same plan: track and meter usage, handle exceptions, upgrade or downgrade, issue credits, and surface the data your CSM needs ahead of renewal.
One flow, from countersigned order form to live customer to renewal conversation.
The standard framing is that custom plans are slow because engineering is a bottleneck. That's not quite right. Engineering isn't a bottleneck because engineers are slow. They're a bottleneck because custom plans, in most stacks, require code. A code exception is a code review. A Stripe price is a migration. A feature flag is a deploy. When the business asks for a custom deal, it's actually asking engineering to ship software.
Custom plans as a first-class object changes what engineering is being asked to do. The one-time integration work is real: instrument entitlement checks, send usage events, handle the webhook callbacks. After that, engineering is out of the per-deal path. Every future custom plan runs through the same system.
What engineering actually wanted all along is to build infrastructure the business can operate on. This is that infrastructure. A single integration that enables the sales org to close any deal the business can imagine, without a new code path for every one.
The obvious unlock is deal velocity. The custom plan stops being a sprint-long project. It's a configuration an AE, solutions engineer, or ops lead completes in the time it takes to read the order form.
The less obvious unlock is what happens after the deal closes. Enterprise customers rarely stay on their launch configuration forever. Limits move. Terms get renegotiated. New products get added. Credits get issued. When custom plans are configuration, the same person who created the plan changes it. The customer gets a faster response. The CSM has the data they need for renewal.
The result is a real quote-to-cash motion: the quote, the order form, the provisioned customer, the metered billing, the lifecycle management, the renewal. One flow, one source of truth.
The Schematic Stripe App already surfaces overrides, usage visibility, and real-time entitlement state inside the Stripe dashboard. We're extending it to support custom plan creation as a full-page app view inside Stripe itself. Your commercial team will be able to provision and manage custom plans end-to-end without leaving the Stripe UI. More on that soon.
