Model-routing transparency is a strategy for products, particularly those using AI or other variable-cost technologies, that allows customers to choose which underlying model or service tier they want to use for a specific task. This choice is typically presented as a trade-off between cost, quality, performance (like latency), and capabilities.

Instead of offering a single, one-size-fits-all solution, you expose the options. This might look like a “good/better/best” selection where:

• Good: A lower-cost, faster model that’s suitable for general tasks.
• Better: A mid-tier model offering a balance of performance and cost.
• Best: A high-end, more expensive model that delivers the highest quality, most power, or most features.

This approach also includes setting a smart, cost-aware default, so users who don’t make a choice are automatically routed to a sensible option, preventing unexpected costs.

Implementing model-routing transparency involves both backend logic and a clear user interface (UI). The system is built on rules that determine which model to use based on user selection or predefined defaults, while tracking the associated costs.

1. Defining the Tiers: First, you identify the different models or service levels you can offer. For an AI product, this could be different language models (e.g., a small, fast open-source model vs. a large, powerful proprietary one). For other services, it could be different data resolution qualities or processing speeds.
2. Pricing Each Tier: Each tier needs a distinct pricing structure. This is often where usage-based or metered billing comes in. For example, the “Good” model might cost $0.001 per request, while the “Best” model costs $0.05 per request. These costs are directly tied to your own operational costs.
3. Designing the User Interface: The user must be able to see the options clearly. This usually happens at the point of action. A good UI will display the trade-offs for each option, such as:
   • Cost: “5 credits” vs. “50 credits”
   • Quality: “Standard quality” vs. “Highest fidelity”
   • Speed: “Fastest” vs. “Slower, more detailed”
4. Implementing Routing Logic: The backend needs to route the user’s request to the selected model. It also needs a default setting. For example, a “cost-saver” mode could be the default, automatically using the cheapest model unless the user specifies otherwise.
5. Tracking and Billing: The system must accurately track usage for each tier and bill the customer accordingly. This requires a robust billing system that can handle metered events and associate them with the correct user and pricing plan.

Giving customers control over their cost and quality trade-offs is more than just a pricing strategy; it’s a way to build trust and increase product adoption.

• Stimulates Usage: Users who are hesitant to use a powerful but expensive feature might be more willing to try a cheaper, lower-tier version. This gets them engaged with the feature and helps them see its value, creating an upsell path.
• Increases Transparency and Trust: When customers understand what they’re paying for and why, they trust the product more. Hiding costs or bundling everything into a single opaque price can lead to suspicion and churn.
• Caters to Diverse Use Cases: A startup building a prototype has very different budget constraints than an enterprise running a critical workflow. Model choice allows both to use your product effectively, expanding your total addressable market.
• Reduces Support Load: Clear, upfront choices prevent “bill shock,” where a customer is surprised by a high invoice. When users select their cost tier, they take ownership of their usage, leading to fewer billing-related support tickets.
• Provides Valuable Product Feedback: Observing which models your customers choose for different tasks gives you direct insight into what they value most, helping you refine your product and pricing strategy over time.

While powerful, this strategy comes with its own set of challenges.

Kinde’s billing infrastructure is designed to handle the complexity of transparent, multi-tiered pricing models, allowing you to build a flexible and user-centric billing experience.

You can create different plans that correspond to your “good/better/best” tiers, each with its own pricing structure. Kinde supports both fixed subscription fees and flexible, usage-based (metered) pricing, which is essential for billing per-request or per-token.

Here’s how you could implement it:

1. Create Your Plans: In Kinde, you can set up distinct plans like “Basic,” “Pro,” and “Enterprise.” You can define what features are included in each.
2. Define Metered Features: For the selectable models, you can create metered features. For example, you could have a feature called “AI Request” and assign a different per-unit price to it in each plan. Or, you could create separate metered features like model_a_usage and model_b_usage and report events to them via the API based on user choice.
3. Build a Pricing Table: Kinde allows you to build and customize a pricing table that clearly presents your plans to users. This UI component is a crucial part of showing the value and cost of each tier.
4. Track Usage via API: Your application reports usage events to the Kinde API. When a user runs a task with the “Best” model, your backend sends an event to Kinde to increment their usage for that specific metered feature. Kinde then handles the rating and billing automatically.

By combining Kinde’s flexible plan and pricing model configuration with a transparent UI in your application, you can empower users to make informed decisions that align with their budget and needs.

• Pricing models
• Create plans
• Build a pricing table
• The Kinde billing model