Revenue Growth Without Profit? How to Calculate and Improve MaaS Gross Margin

    This article uses a listed Chinese large-model company’s first annual report to show how MaaS ARR, unit economics, and gross margin actually work. It covers ARR definitions, a token-level cost model with batching, prefix cache, and speculative decoding, plus customer-mix and KPI levers that can lift API gross margin without assuming price increases.

    1. Sample data and definitions

    This analysis uses the first full-year report publicly disclosed by a listed Chinese large-model company. All figures come from that filing; calculations are based on the disclosed numbers and are not independently audited. Always verify against the original announcement.

    Key figures:

    • Full-year revenue of about RMB 724 million, up 131.9% year over year.
    • MaaS API platform annual recurring revenue (ARR) of about RMB 1.7 billion, described as roughly 60 times the prior year.
    • MaaS API platform gross margin rose from 3.3% in 2024 to 18.9% in 2025.

    Revenue figures are internally consistent. Revenue was RMB 57 million, RMB 125 million, and RMB 312 million in 2022–2024. 724 / 312 is about 2.32, matching 131.9% growth.

    The framework applies to MaaS in general: any team serving models via API, whether on self-built inference clusters or in the cloud.

    2. ARR: check the definition before the number

    2.1 What ARR includes

    ARR (annual recurring revenue) is borrowed from SaaS. It measures the run-rate of repeatable revenue. For token billing, it is typically monthly recurring revenue at a point in time times 12.

    It is a run rate, not accrual revenue, and should not be equated with income-statement revenue. One-off project revenue can be large but ends at delivery and does not show whether customers keep using the model.

    2.2 Relating the two numbers

    Year-end ARR of RMB 1.7 billion versus full-year revenue of RMB 724 million is a ratio of about 42.6%.

    If ARR grew linearly from zero, full-year revenue would be about half of year-end ARR, or RMB 850 million. Actual revenue is lower, which means growth was back-loaded and/or year-end run rate includes usage not fully recognized. Quarterly or monthly data would distinguish the two.

    Year-end ARR of RMB 1.7 billion implies a monthly run rate of about RMB 142 million.

    Working backward from “about 60 times last year,” prior-year ARR was about RMB 28 million. That was only about 9% of 2024 total revenue (RMB 312 million), so MaaS was a small share in 2024 and became the main growth driver in 2025.

    Do not linearly extrapolate that multiple. Low-base growth fades with scale. Year-over-year increment and net revenue retention matter more.

    2.3 Strip what should not be in ARR

    Exclude one-time fees (customization, labeling, fine-tuning), unused portions of long contracts, and contracted quotas that were never invoked.

    1. from dataclasses import dataclass
    2. @dataclass
    3. class Contract:
    4. monthly_usage_fee: float # fees from actual token consumption this month
    5. is_one_time: bool # whether this is a one-off project
    6. def clean_arr(contracts: list[Contract]) -> float:
    7. """Annual recurring revenue from actual consumption."""
    8. # unused quotas have monthly_usage_fee = 0 and drop out
    9. return sum(c.monthly_usage_fee * 12 for c in contracts if not c.is_one_time)
    10. contracts = [
    11. Contract(monthly_usage_fee=200_000, is_one_time=False),
    12. Contract(monthly_usage_fee=500_000, is_one_time=True),
    13. Contract(monthly_usage_fee=0, is_one_time=False),
    14. ]
    15. print(clean_arr(contracts)) # 2400000

    Net revenue retention (NRR) is a better quality signal than ARR total:

    1. def net_revenue_retention(start_arr: float, expansion: float,
    2. churn: float, contraction: float) -> float:
    3. """NRR = (start ARR + expansion - churn - contraction) / start ARR"""
    4. return (start_arr + expansion - churn - contraction) / start_arr
    5. print(round(net_revenue_retention(1000, 300, 120, 30), 2)) # 1.15

    NRR above 100% means existing customers can grow revenue without new logos—the key difference between token consumption and one-off projects.

    3. Unit economics: why revenue can grow without profit

    MaaS costs include inference compute (accelerator depreciation or rent, power, facilities), storage and networking, model R&D amortization, and enterprise SLA/support. Inference moves fastest with traffic. Accelerators are bought for peak; if traffic lags, depreciation per token rises.

    Gross margin at the token:

    Gross margin = 1 − inference cost per token / price per token

    Cost per token = all-in GPU-hour cost ÷ tokens produced per GPU-hour

    Price is constrained by competition in the short run. GPU-hour cost is set by hardware and procurement. Tokens per GPU-hour is the lever engineering can move.

    1. from dataclasses import dataclass
    2. @dataclass
    3. class UnitEconomics:
    4. price_per_mtok: float # list price (currency per million output tokens)
    5. gpu_hour_cost: float # all-in cost per GPU-hour
    6. tokens_per_s: float # measured output tokens/s at target batch size
    7. acceptance_rate: float = 0.0 # speculative decoding accept rate; 0 = off
    8. draft_len: int = 4 # draft tokens per round
    9. draft_cost_ratio: float = 0.1 # draft forward time vs target model
    10. input_share: float = 0.0 # share of cost on the prefill/input side
    11. cache_hit_ratio: float = 0.0 # prefix-cache hit rate
    12. cache_discount: float = 0.1 # cost coefficient of hits vs misses
    13. def speedup(self) -> float:
    14. """Effective throughput multiplier from speculative decoding, net of draft cost."""
    15. a, k = self.acceptance_rate, self.draft_len
    16. if a == 0:
    17. return 1.0
    18. expected = k + 1.0 if a >= 1 else (1 - a ** (k + 1)) / (1 - a)
    19. return expected / (1 + self.draft_cost_ratio * k)
    20. def cache_factor(self) -> float:
    21. """Cost coefficient after prefix cache; < 1 means lower cost."""
    22. return 1 - self.input_share * self.cache_hit_ratio * (1 - self.cache_discount)
    23. def cost_per_mtok(self) -> float:
    24. """Inference cost per million tokens."""
    25. tokens_per_hour = self.tokens_per_s * self.speedup() * 3600
    26. return self.gpu_hour_cost / tokens_per_hour * 1_000_000 * self.cache_factor()
    27. def gross_margin(self) -> float:
    28. return 1 - self.cost_per_mtok() / self.price_per_mtok
    29. base = UnitEconomics(price_per_mtok=10, gpu_hour_cost=8, tokens_per_s=240)
    30. batch = UnitEconomics(price_per_mtok=10, gpu_hour_cost=8, tokens_per_s=330)
    31. cache = UnitEconomics(price_per_mtok=10, gpu_hour_cost=8, tokens_per_s=330,
    32. input_share=0.5, cache_hit_ratio=0.8)
    33. full = UnitEconomics(price_per_mtok=10, gpu_hour_cost=8, tokens_per_s=330,
    34. input_share=0.5, cache_hit_ratio=0.8, acceptance_rate=0.8)
    35. for name, e in [("baseline", base), ("larger batch", batch),
    36. ("plus prefix cache", cache), ("plus speculative decoding", full)]:
    37. print(name, round(e.gross_margin() * 100, 1))
    38. print(round(full.speedup(), 2))

    Output: baseline 7.4, larger batch 32.7, plus prefix cache 56.9, plus speculative decoding 82.1, speculative speedup 2.4.

    Example assumptions: price 10 per million output tokens, GPU-hour cost 8. Larger batch raises throughput from 240 to 330 tokens/s. Input is half of cost, cache hit rate 80%, hit cost coefficient 0.1. Speculative accept rate 0.8, draft length 4, draft forward 10% of the target model.

    These are idealized upper bounds; 82% is not a forecast. Speculative gains fall at high concurrency; cache hit rates vary by workload; batch size is capped by SLA queueing. The point is sensitivity: throughput and cache hits move margin far more than small price changes.

    Company-wide gross margin and MaaS API gross margin are different. Private deployments often put compute on the customer’s infrastructure; token-billed API revenue and cost are tightly linked. As API mix rises, overall margin can be structurally diluted. The move from 3.3% to 18.9% MaaS margin shows token-billed business can improve along the cost curve—it does not need to match overall margin.

    4. Path 1: compress token cost with inference efficiency

    Continuous batching and phase split. Inference has prefill and decode. Prefill is compute-bound and sets time to first token; decode is memory-bandwidth bound and sets per-output-token latency. Waiting for a full batch idles GPUs in decode. Continuous batching schedules at iteration granularity: finished requests leave immediately and new ones join. Long prefills can block others; common fixes are chunked prefill or separate resource pools for the two phases, with different GPU types and independent scaling.

    KV cache and prefix cache. KV memory is roughly 2 × layers × KV heads × head dim × sequence length × bytes per element. That caps concurrency per GPU. System prompts, tool schemas, knowledge context, and multi-turn history often share prefixes; prefix cache reuses that compute.

    1. def prefill_cost(input_tokens: int, hit_ratio: float,
    2. miss_cost_coeff: float, hit_cost_coeff: float) -> float:
    3. """Estimate input-side cost with prefix cache."""
    4. return input_tokens * ((1 - hit_ratio) * miss_cost_coeff + hit_ratio * hit_cost_coeff)
    5. print(round(prefill_cost(8000, hit_ratio=0.9, miss_cost_coeff=1.0, hit_cost_coeff=0.1))) # 1520

    Here, 8,000 input tokens drop to about 19% effective compute. Hit rates are high when an enterprise shares a fixed template, and low for open chat across many developers.

    Speculative decoding. A draft model guesses several tokens; the target verifies them in one forward. With draft length k and accept rate α, expected tokens per round is (1 − α^(k+1)) / (1 − α). For k = 4, α of 0.6, 0.8, 0.9 yields about 2.31, 3.36, 4.10 tokens per round. Net of draft cost, α = 0.8 is about 2.4×. Gains are higher on predictable tasks (code completion, structured extraction). Idle GPUs at low concurrency help; at high concurrency, verification overhead can erase the gain.

    Quantization, sparsity, distillation. Quantizing weights and KV to INT8, FP8, or INT4 trades accuracy; validate on a business eval set. MoE activates a subset of experts, cutting compute per token, but memory does not fall in proportion. Distillation routes frequent, simple requests to a small model with a large model as fallback.

    Length control. Output tokens cannot be prefix-cached and must be generated one by one. Cap max output by task, compress or RAG long context, and plan capacity under SLO constraints.

    5. Path 2: raise value per customer via mix

    A larger share of head accounts is the other margin driver. Large customers have steadier usage, better capacity planning, larger batches, and better absorption of fixed cost. Enterprise apps share system prompts and knowledge bases, so cache hits are high. They also pay for isolation, SLA, reserved capacity, and support. Deep integration raises switching costs, NRR, and predictability.

    Long-tail, purely usage-based developers are the opposite: volatile revenue, free-tier burn, sparse request shapes, weak cache, and calls that may not be profitable.

    Pricing can use tiers, committed-use discounts, reserved plus on-demand mix, and separate output-token prices because output is usually much more expensive than input. Simulate margin with the unit-economics model before any price change.

    Monitor concentration. Illustrative thresholds only: a single customer above 10% of ARR goes on a watch list; top 10 above 50% is a warning; a single industry above 30% should trigger expansion.

    6. Metrics

    Dimension Core metrics Direction Effect on margin
    Efficiency Tokens per GPU, average batch size, utilization Increase Dilute all-in GPU-hour cost
    Cache Prefix-cache hit rate Increase Cut repeated prefill
    Acceleration Speculative accept rate Increase Raise effective throughput
    Experience TTFT, TPOT, SLO attainment Hold the floor Support premium and renewal
    Commercial Head-account share, committed usage, NRR Increase Make revenue more predictable
    Finance Gross margin by customer, cost per token Monitor Find and fix unprofitable traffic

    Efficiency and customer mix multiply. Efficiency alone on low-margin traffic gives savings away in price wars. High-value customers without efficiency leave idle compute eating profit.

    7. Pre-production checklist and risks

    1. Quantization: compare to baseline on a business eval set; roll back if core-task accuracy drops beyond an agreed threshold (e.g., 1 percentage point). Ship behind a 5% traffic canary.
    2. Prefix cache: cache keys must include tenant identity. Probe with cross-tenant requests for leakage and keep a one-click kill switch.
    3. Speculative decoding: watch accept rate by task; auto-disable a task type if it stays below a threshold (e.g., 0.6).
    4. ARR definition: reconcile ARR to billing monthly; pause external disclosure if variance exceeds an agreed ratio.
    5. Concentration: review the thresholds in sections 2 and 5 monthly, and track NRR and churn.

    8. Conclusion

    The filing’s most useful signal is not RMB 1.7 billion ARR or 131.9% growth, but MaaS gross margin moving from 3.3% to 18.9%. Token-billed business is not doomed to grow revenue without profit. Margin depends on two things: engineering that lowers compute cost per token, and a commercial mix where high-value customers dominate revenue.

    Individual developers should evaluate cache support, context handling, and elasticity—not unit price alone. For enterprise teams, a unit-economics model should be the first step in productionizing large-model applications.