MaaS Platform Architecture and Token Cost Governance in Practice

    As large-model vendors shift from project-based delivery to API-subscription billing, the engineering challenge moves from "can we deliver" to "is every call measurable, controllable, and optimizable." This article presents the layered architecture of a Model-as-a-Service (MaaS) platform and a practical approach to token cost governance under the simultaneous pressures of inference cost, concurrency, and price competition. It covers the six layers—access, scheduling, inference, service, metering, and observability—and details dual-dimension rate limiting (RPM and TPM), tiered model routing, prefix and request-level caching, continuous batching and KV cache management, elastic scaling and priority queues, idempotent token metering, a measure–attribute–optimize–validate cost-governance pipeline, observability design, common pitfalls, and a three-phase implementation path.

    Introduction: From Project Delivery to API Subscription

    The business model of large-model vendors is quietly shifting. Early on, most revenue came from on-premises deployment for government and enterprise clients and from project-based delivery, with revenue recognized against contracts, long delivery cycles, and high marginal cost. Today more vendors are pivoting to open platforms: developers pay per token, and enterprise clients purchase services through subscriptions or resource packages. Platforms such as Baidu AI Cloud also package “model capabilities + compute resources + companion tooling” into callable services through model-service offerings like Qianfan. This shift may sound like a mere change in billing, but for engineering teams it is a systemic rebuild.

    Let me unpack the “API subscription” idea: in practice it usually maps to three billing models, with very different engineering implementations:

    • Pay-as-you-go (postpaid): billed by input/output token usage, with fine settlement granularity and the highest demands on metering accuracy.
    • Prepaid resource packages: buy a quota first, then draw it down. This essentially swaps “postpaid” for a “prepaid ledger,” involving balances, validity periods, and stacking of multiple packages.
    • Fixed-period subscriptions: a fixed fee per month or year, bundled with a call allowance or concurrency cap, closer to traditional SaaS. The key is quota design and overage policy.

    Whatever the model, the core of the system shifts from “can we deliver” to “is every call measurable, controllable, and optimizable.” This article centers on the architecture of a MaaS (Model-as-a-Service) platform and systematically examines how to build a platform that is both stable and economical when inference cost, concurrency pressure, and price competition all coexist.

    1. Why the Business-Model Shift Forces an Architecture Upgrade

    Moving from private deployment to multi-tenant service changes the technical constraints on at least four levels:

    1. Revenue shifts from “one-off” to “continuous and volatile.” Project revenue is recognized at project acceptance; API revenue is generated continuously with every call and, at the same time, consumes compute with every call. Gross margin no longer depends on whether a single project ships on time, but on whether the gap between per-request cost and per-request revenue can stay positive over the long term.

    2. Load characteristics shift from “known peaks” to “unpredictable long tails.” Private deployment capacity can be estimated from contract size; an open platform faces massive numbers of developers and enterprise clients, with traffic showing clear tidal swings and burst peaks. Capacity planning must move from static estimation to elastic scaling.

    3. Resource usage shifts from “dedicated” to “co-located.” Requests from multiple tenants share the same pool of GPU inference instances. One tenant’s traffic burst can affect other tenants’ response latency, so quota, priority, and queueing mechanisms are required.

    4. Revenue recognition depends on metering. The billed amount is driven by actual token usage, and metering errors are directly amplified into reconciliation disputes and lost revenue. The metering pipeline must be complete, traceable, and auditable.

    One notable phenomenon: when vendors compete for developers by cutting API unit prices, the erosion of gross margin from a price cut depends not only on the size of the cut but also on the vendor’s own unit-cost level. This means cost governance is shifting from an “optimization item” to a “competitive advantage.”

    2. The Layered Architecture of a MaaS Platform

    A production-ready MaaS platform can usually be abstracted into six layers:

    1. ┌─────────────────────────────────────────────────────────────┐
    2. │ Access layer: auth / quota checks / rate limiting & queuing /
    3. │ multimodal input preprocessing │
    4. ├─────────────────────────────────────────────────────────────┤
    5. │ Scheduling layer: model routing / prefix cache reuse / │
    6. │ context assembly │
    7. ├─────────────────────────────────────────────────────────────┤
    8. │ Inference layer: batch scheduling / KV cache management / │
    9. │ tensor & pipeline parallelism │
    10. ├─────────────────────────────────────────────────────────────┤
    11. │ Service layer: elastic scaling / elastic queue / │
    12. │ warmup & cold start │
    13. ├─────────────────────────────────────────────────────────────┤
    14. │ Metering layer: usage collection / idempotent accounting / │
    15. │ billing & usage queries │
    16. ├─────────────────────────────────────────────────────────────┤
    17. │ Observability: metrics / logs / tracing / cost accounting & │
    18. │ capacity planning │
    19. └─────────────────────────────────────────────────────────────┘

    The goal of layering is not to “look complete,” but to give each layer a clear responsibility boundary and interfaces that can evolve independently. For example, the metering layer only cares about “who called which model at what moment and how many tokens were consumed,” without needing to know how the inference layer performs batch scheduling. The two are decoupled through a unified event format. The following sections discuss key design points layer by layer and provide illustrative code.

    3. Access Layer: Authentication, Quota, and Rate Limiting

    The access layer is the platform’s first gate and the starting point of multi-tenant governance.

    3.1 Authentication and the Tenant Model

    Authentication on open platforms is usually based on API keys or short-lived access tokens. Several boundaries need to be defined in the design:

    • API keys are identifiers, not permission carriers: permissions are bound through the tenant model (individual developers, teams, enterprises) and roles, avoiding “one key for everything.”
    • Keys must be rotatable and revocable: support multiple simultaneously valid keys to ease gray/canary switching; once revoked, reject all requests within a short window while retaining audit records.
    • Request context is uniformly packaged: tenant ID, application ID, call source, plan tier, and other information travel with the request across the entire chain, feeding downstream quota, routing, and billing decisions.

    3.2 Dual-Dimension Rate Limiting: RPM and TPM

    Simple “requests per second” limiting is not enough for large-model services. A single long-context request can consume tens of thousands of tokens, occupying far more memory and compute than ten short requests. Mature platforms usually use two dimensions:

    • RPM (requests per minute): controls connection count and scheduling overhead, preventing high-frequency churn.
    • TPM (tokens per minute): controls actual resource consumption and is the core metric for protecting the inference cluster.

    Both apply together—limiting triggers when either dimension is exceeded. A token bucket is the classic implementation: tokens refill at a fixed rate, each request deducts according to actual consumption, burst traffic can borrow from the stored balance, and steady periods return to the base rate.

    1. import threading
    2. import time
    3. class TokenBucket:
    4. """Single-node token bucket for illustration; production should replace it with a distributed rate-limiting service."""
    5. def __init__(self, capacity: float, refill_per_second: float):
    6. self._capacity = capacity # Bucket capacity: the maximum allowed burst
    7. self._refill_rate = refill_per_second
    8. self._tokens = capacity
    9. self._updated_at = time.monotonic()
    10. self._lock = threading.Lock()
    11. def acquire(self, cost: float = 1.0) -> bool:
    12. with self._lock:
    13. now = time.monotonic()
    14. # Refill tokens based on elapsed time; lazy computation avoids a background thread
    15. self._tokens = min(
    16. self._capacity,
    17. self._tokens + (now - self._updated_at) * self._refill_rate,
    18. )
    19. self._updated_at = now
    20. if self._tokens < cost:
    21. return False
    22. self._tokens -= cost
    23. return True
    24. # 60 requests per minute => 1 req/s; 600K tokens per minute => 10K tokens/s
    25. RPM_BUCKET = TokenBucket(capacity=60, refill_per_second=1.0)
    26. TPM_BUCKET = TokenBucket(capacity=600_000, refill_per_second=10_000.0)
    27. def admission_check(tenant_id: str, est_tokens: int) -> bool:
    28. """Admission check at the access layer: apply dual-dimension rate limiting first, then per-tenant quota validation.
    29. When it returns False, the caller should return 429 with a suggested retry time.
    30. """
    31. if not RPM_BUCKET.acquire():
    32. return False
    33. if not TPM_BUCKET.acquire(est_tokens):
    34. return False
    35. # Per-tenant monthly quota check: illustrative here; production must query a quota service
    36. return check_quota(tenant_id, est_tokens)

    Note: In a multi-instance deployment, a single-node token bucket can inflate the total quota because each instance holds its own share. Production designs typically push quotas to a shared rate-limiting service or config center, with each instance allocating a local share by weight.

    3.3 Queueing and Fast Failure

    When the inference cluster nears saturation, the platform faces two choices: infinite queueing or fast failure. The former lets waiting requests pile up and eventually fail collectively as timeouts, creating an “avalanche”; the latter returns a clear error code immediately when resources are insufficient, with an estimated recovery time, turning uncertainty into predictable behavior.

    The recommended approach is two thresholds: a soft threshold (e.g., queue utilization reaching 70%) triggers scaling and alerting; a hard threshold (e.g., reaching 95%) triggers proactive rejection. Combined with exponential backoff on the client side, overall availability is usually higher than “accept everything.”

    3.4 Input-Side Governance

    • Context-length validation: validate input length against the model’s window before scheduling; when exceeded, truncate, summarize, or reject per policy to avoid passing oversized requests to the inference layer and wasting compute.
    • Multimodal input preprocessing: image, audio, and video inputs must be resized, normalized, and compressed before entering the model. This part typically consumes considerable CPU and should be its own layer with independent rate limiting.
    • Safety filtering: run compliance checks on inputs and outputs; intercept suspicious requests outright to avoid consuming inference resources.

    4. Scheduling Layer: Model Routing and Caching

    4.1 Tiered Routing by Task Complexity

    Different tasks have very different model-capability needs: intent recognition, text classification, and format conversion are often handled by lightweight models, while complex reasoning, long-document understanding, and code generation require stronger models. If all requests go to the strongest model, cost stays high.

    The core idea of tiered routing is “classify first, then assign.” Based on request metadata (such as task type declared by the caller), input features (length, degree of structure), or a lightweight scoring model, you decide which model tier to actually invoke.

    1. from dataclasses import dataclass
    2. @dataclass(frozen=True)
    3. class ModelRoute:
    4. model: str # Logical model name; no specific product identifier
    5. max_context: int # Context window
    6. price_in: float # Input price, per 1K tokens (illustrative)
    7. price_out: float # Output price, per 1K tokens (illustrative)
    8. ROUTES = {
    9. "fast": ModelRoute("fast", max_context=32_768, price_in=0.001, price_out=0.002),
    10. "standard": ModelRoute("standard", max_context=131_072, price_in=0.004, price_out=0.012),
    11. "advanced": ModelRoute("advanced", max_context=131_072, price_in=0.02, price_out=0.06),
    12. }
    13. def choose_route(task_type: str, prompt_tokens: int) -> ModelRoute:
    14. """Choose a route by task type and context length; the example policy must be adjusted per workload."""
    15. if task_type in ("classify", "extract", "format"):
    16. return ROUTES["fast"]
    17. if task_type in ("reason", "codegen"):
    18. return ROUTES["advanced"] if prompt_tokens > 8_000 else ROUTES["standard"]
    19. # For long context, satisfy the window requirement first, then fall back
    20. for key in ("standard", "fast"):
    21. if prompt_tokens <= ROUTES[key].max_context:
    22. return ROUTES[key]
    23. return ROUTES["advanced"]

    A more refined approach is “cascading calls”: use a lightweight model first to produce an answer and confidence score, then escalate to a stronger model when confidence is insufficient. This can significantly reduce average cost, but it requires additional confidence-scoring logic and handling the latency stacking between the two levels.

    4.2 Prefix Cache Reuse

    Large-model inference builds the KV cache progressively for input tokens, and this computation and memory footprint grow with context length. When many requests share the same prefix (e.g., a shared system prompt, fixed tool descriptions, or repeated Q&A over the same long document), reusing the prefix’s KV cache avoids redundant computation.

    Key points:

    • Prefix hash chunking: split the context into fixed-size chunks and compute hashes level by level; a hit on the longest common prefix lets you reuse the corresponding chunks.
    • Memory budget management: the KV cache occupies GPU memory, so scheduling must assess available memory against expected usage to avoid “a cache hit that actually slows everything down.”
    • Invalidation and consistency: the KV cache for a prefix must be invalidated when the model version or parameters change, or it will introduce semantic errors.

    4.3 Request-Level Caching

    For identical requests, you can return cached results directly at the access layer. The key design is cache-key construction: it should include the model identifier, the normalized message sequence, key inference parameters (such as temperature and max output length), and the platform version, to avoid “same question, different answer” caused by parameter differences.

    1. import hashlib
    2. import json
    3. def build_cache_key(model: str, messages: list, params: dict, platform_version: str) -> str:
    4. """Build a request-level cache key: canonically serialize messages and key params, then hash."""
    5. payload = {
    6. "model": model,
    7. "messages": messages,
    8. "params": {
    9. "temperature": params.get("temperature", 0.7),
    10. "max_tokens": params.get("max_tokens"),
    11. "top_p": params.get("top_p", 1.0),
    12. },
    13. "platform": platform_version,
    14. }
    15. raw = json.dumps(payload, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
    16. return hashlib.sha256(raw.encode("utf-8")).hexdigest()

    Note: request-level caching only pays off for deterministic tasks (e.g., fixed Q&A, structured extraction); for creative generation, different requests should produce different results even with identical inputs, so caching should be disabled or a random factor introduced into the cache key.

    5. Inference Layer: Batch Scheduling and KV Cache Management

    The inference layer determines the ceiling on unit cost. Several key techniques matter here:

    1. Continuous batching. Traditional static batching waits for an entire batch to finish before releasing resources, and long-tail requests slow down the whole batch. Continuous batching schedules at the “step” level: a request is removed from the batch as soon as it finishes generating, and the freed slot is immediately filled by a new request, significantly boosting GPU utilization. The cost is more complex scheduling logic and careful handling of each request’s memory footprint.

    2. Chunked KV cache management. Rather than reserving one contiguous block of memory per request (which causes fragmentation and wasted reservation), it is better to manage the KV cache in blocks, allocating on demand and stitching dynamically. This is a general approach for improving memory utilization and supporting high concurrency.

    3. Parallelism strategies. When model size exceeds single-card memory, you must split deployment using tensor parallelism (splitting a single layer’s computation across cards) or pipeline parallelism (assigning different layers to different cards). The two differ in communication overhead and scaling efficiency: tensor parallelism communicates frequently and suits intra-node high-bandwidth interconnects; pipeline parallelism communicates less but is sensitive to bubbles (pipeline idle time). Production deployments often combine them and tune against measured memory and throughput.

    4. Context-length control. Longer inputs mean larger KV cache usage and more computation, raising per-token cost. The platform should provide context-compression capabilities: summarizing dialogue history, reranking and truncating retrieved snippets, deduplicating repeated content—compressing input size while preserving quality.

    6. Service Layer: Elastic Scaling and Queue Governance

    Elasticity determines whether the platform can “catch” traffic floods and “not waste” during troughs.

    • Choosing the right scaling metric: for inference services, GPU utilization does not always reflect real pressure (utilization may be low while waiting for memory or scheduling). More reliable metrics include request queue latency, batch queue length, and P95 response time.
    • Cold start is the core tension: starting GPU instances, loading model weights, and initializing memory typically takes a long time. Countermeasures include keeping a proportion of warm-standby instances, caching model weights locally, and using a “small-step” scaling strategy to avoid oscillation.
    • Warmup and probes: before a new instance joins the load, run several inference warmups to confirm memory allocation and kernel compilation are complete, then add it to service, avoiding timeouts on the first batch of requests.
    • Priority queues: divide priority by plan tier; during peaks, prioritize the SLA of high-priority tenants, let low-priority requests enter the elastic queue, and process them when resources free up.
    1. import heapq
    2. import time
    3. from dataclasses import dataclass, field
    4. from typing import List
    5. @dataclass(order=True)
    6. class Request:
    7. """Priority queue: a lower priority value dequeues first; ties are ordered by enqueue time."""
    8. priority: int
    9. enqueued_at: float = field(default_factory=time.monotonic, compare=False)
    10. payload: dict = field(default_factory=dict, compare=False)
    11. class PriorityQueue:
    12. def __init__(self):
    13. self._heap: List[Request] = []
    14. def push(self, req: Request) -> None:
    15. heapq.heappush(self._heap, req)
    16. def pop(self) -> Request | None:
    17. return heapq.heappop(self._heap) if self._heap else None
    18. def oldest_waiting(self) -> float:
    19. """Return the head-of-queue wait time, used to trigger scaling or degradation decisions."""
    20. if not self._heap:
    21. return 0.0
    22. return time.monotonic() - self._heap[0].enqueued_at

    7. Metering Layer: Token Metering and Idempotent Accounting

    Metering is the “heart” of the API-subscription model. Its difficulty is not “counting tokens” but “counting accurately, reconciling correctly, and staying traceable.”

    7.1 Input-Side Estimation vs. Output-Side Exactness

    • Input tokens: once the caller submits content, the platform can count precisely before inference using a tokenizer matched to the model. The tokenizer is part of the model, and different models tokenize at different granularities. Estimation formulas can only be used for rate-limiting prediction, not as a billing basis.
    • Output tokens: generation is a streaming process and must be tallied by actual output after generation completes. Streaming scenarios also need to handle clients disconnecting mid-way—whether already-generated content is billed should be defined in the product rules (a common approach is to bill by actual generated volume).
    • Errors and retries: failed requests are usually not billed or are charged only for the compute already incurred; retry requests must carry an idempotency identifier to avoid duplicate billing.

    7.2 Idempotent Accounting

    Metering data under high-frequency calls creates enormous write volume and must go through an event-driven asynchronous pipeline: the access layer only generates usage events and publishes them to a message queue, and an independent accounting service consumes and persists them. Accounting must be idempotent:

    1. import hashlib
    2. import json
    3. from dataclasses import asdict, dataclass
    4. @dataclass(frozen=True)
    5. class UsageRecord:
    6. request_id: str # Globally unique request identifier
    7. tenant_id: str # Tenant identifier
    8. app_id: str # Calling application identifier
    9. model: str # Model actually invoked
    10. prompt_tokens: int # Input tokens
    11. completion_tokens: int # Output tokens
    12. cached_tokens: int = 0 # Input tokens served from cache (already included in prompt_tokens)
    13. status: str = "success" # success / failed / cancelled
    14. created_at: float = 0.0 # Populated downstream
    15. def build_usage_event(request_id, tenant_id, app_id, route, usage, status="success") -> str:
    16. """Package a single call as a usage event; request_id serves as the idempotency key."""
    17. record = UsageRecord(
    18. request_id=request_id,
    19. tenant_id=tenant_id,
    20. app_id=app_id,
    21. model=route.model,
    22. prompt_tokens=usage["prompt_tokens"],
    23. completion_tokens=usage["completion_tokens"],
    24. cached_tokens=usage.get("cached_tokens", 0),
    25. status=status,
    26. )
    27. return json.dumps(asdict(record), ensure_ascii=False)
    28. def record_idempotency_key(event: dict) -> str:
    29. """Generate an idempotency key from request_id + event type for downstream deduplication."""
    30. raw = f"{event['request_id']}::{event['status']}"
    31. return hashlib.sha256(raw.encode("utf-8")).hexdigest()

    When the downstream accounting service consumes events, it uses the idempotency key as a uniqueness constraint (e.g., a database unique index), so duplicate messages are naturally discarded. Combined with at-least-once delivery semantics, this guarantees no lost charges and no double charges.

    7.3 Billing Cycles and Quota Coordination

    • Real-time quota deduction: in the prepaid resource-package scenario, perform a “reservation” before each call and settle the difference by actual usage after the call, preventing concurrent calls from blowing through the quota.
    • Billing cycles and reconciliation: in the postpaid scenario, bill per calendar month and provide usage-detail queries (by tenant, application, model, and time) so customers can reconcile on their own.
    • Arrears and degradation: when quota is exhausted, handle per policy—hard rejection, degradation to a low-cost model, or transfer to a waiting queue—decided by product rules.

    8. Cost Governance: Turning “Cost Saving” into a System

    Cost governance is not a single optimization point but a pipeline running throughout. Advance it in four steps: measure—attribute—optimize—validate.

    8.1 Measure: Establish Unit-Cost Metrics

    • Cost per token: total cost ÷ total tokens, the most core efficiency metric.
    • Cost per request: amortized by request count, reflecting scheduling and network overhead.
    • Cache hit rate: the hit ratio of prefix caching and request-level caching, which directly determines reuse gains.
    • GPU utilization and memory occupancy: distinguish “compute-bound” from “memory-bound” to guide parallelism strategy and instance-spec selection.

    8.2 Attribute: Costs Must Trace to Tenants and Scenarios

    Splitting compute cost by tenant, application, model, and call scenario lets you judge “which workloads make money and which lose it.” A common approach is to tag inference instances by tenant (or record the request-to-instance mapping during scheduling) and then allocate costs against instance cost. Cost optimization without attribution capability often “optimizes the average at the expense of the individual.”

    8.3 Optimize: Levers at Multiple Levels

    Layer Techniques Main benefit
    Model layer Tiered routing, cascading calls, model distillation Lower average cost per request
    Inference layer Continuous batching, chunked KV cache, prefix reuse Higher throughput and memory utilization
    Input layer Context compression, retrieved-result trimming Smaller input token volume
    Service layer Elastic scaling, warm-standby instances, off-peak scheduling Less idle waste
    Billing layer Cache billing policy, resource-package design Greater control on the revenue side

    An easily overlooked point is off-peak scheduling: batch tasks (e.g., offline summarization, bulk annotation) are latency-insensitive and can be scheduled to traffic troughs, trading “time for cost.” The platform can offer an asynchronous batch-processing interface to strip such loads out of the online path.

    8.4 Validate: Optimization Must Be Quantifiable

    Every optimization should set up a controlled experiment: fix a traffic slice and compare unit cost, P95 latency, and task quality (e.g., accuracy, manual spot-check pass rate) before and after. Cost optimization without a quality gate may come at the expense of service quality.

    9. Observability: Making Every Call Explainable

    9.1 Metric System

    Cover at least four dimensions:

    • Traffic: QPS, token throughput (input and output tracked separately), tenant distribution.
    • Latency: time-to-first-token (TTFT), per-token generation latency, end-to-end P95/P99.
    • Quality: error rate (distinguishing rate limiting, timeouts, model errors, content-safety blocks), truncation rate.
    • Cost: cost per token, cache hit rate, GPU utilization, cost per 10K calls.

    9.2 Tracing and Logging

    Use request_id as the trace identifier across the entire chain, linking the access, scheduling, inference, and metering layers. Logs should record key decisions (which route was chosen, whether the cache was hit, how long the queue wait was), so problems can be “replayed per request” rather than only viewed as aggregate metrics.

    9.3 Alert Design

    Alerts should distinguish “symptoms” from “root causes”:

    • Symptom alerts: sudden error-rate spikes, P95 latency over threshold, continuously growing queue length—for on-call response.
    • Root-cause alerts: GPU memory near its limit, sharp drops in prefix-cache hit rate, unhealthy model-service instances—for capacity and stability governance.

    For thresholds, use a “baseline + year-over-year/period-over-period” approach to avoid frequent false alarms from static thresholds during natural traffic fluctuations.

    10. Common Pitfalls and Implementation Advice

    Pitfall 1: Single-dimension rate limiting. Watching only QPS and not token volume lets long-context requests punch through the cluster. RPM and TPM must constrain together.

    Pitfall 2: Tight coupling of metering and inference. If billing logic is embedded in the inference process, inference jitter directly affects accounting integrity. Usage events should be decoupled via a message queue and persisted asynchronously.

    Pitfall 3: Coarse cache keys. Keying only on message content while ignoring model parameters and platform version leads to “same question, different answer” or “still returning old results after an upgrade.”

    Pitfall 4: Cost optimization without a quality gate. Pursuing low-cost model routing alone can significantly hurt task quality and ultimately backfire on revenue through customer churn.

    Pitfall 5: Ignoring cold start. If the elastic scaling strategy ignores GPU instance load time, scaling is always “half a beat late,” and large-scale timeouts are inevitable during peaks.

    Advance implementation in three phases:

    1. Phase 1 (Measurable): connect authentication, rate limiting, usage collection, and idempotent accounting to ensure “every call is fully accounted for.”
    2. Phase 2 (Optimizable): introduce tiered routing, prefix caching, and request-level caching, and build a unit-cost dashboard.
    3. Phase 3 (Elastic): complete priority queues, elastic scaling, and disaster-recovery degradation to form an SLA-oriented capacity system.

    Conclusion

    Moving from project delivery to API subscription appears to be a change in billing, but in essence it turns large-model capabilities into a service that must be operated continuously. For engineering teams, real competitiveness lies not in “how many models are integrated” but in whether every call can be metered clearly, constrained properly, and kept cost-controlled. When API price competition becomes the norm, the ability to balance cost governance against service quality is the foundation on which a platform stands for the long term.