Anyone who has used AI coding tools knows the feeling. Plug in an API key and pay per token, and every keystroke feels like watching a taxi meter tick upward. Switch to a flat monthly subscription, and the psychology flips: the money is already spent, so every extra query feels like free leverage.
That psychological gap was recently validated inside Revolut, Europe’s largest digital bank. Regulated in the EU, Revolut serves 80 million customers and reached a $115 billion valuation in July 2026. David Abitbol, who leads AI operations and infrastructure at the company, shared a full year of real-world ledger data across roughly 2,000 engineers in a talk at AI Engineer NYC.
They started with a detour. In January 2025, they rolled out Gemini to help teams search internal documentation. Actual coding hours dropped by 20%. Yet end-to-end delivery lead time—from picking up a feature ticket to merging production-ready code—fell by only 10%.
By January 2026, the company was rolling out Claude Code at scale. Productivity gains remained modest, while individual monthly bills climbed to between $1,000 and $10,000 per engineer, forcing the company to impose strict personal budget caps.
The turning point came on April 26, 2026. Revolut rented 56 of NVIDIA’s flagship B200 GPUs and self-hosted Zhipu’s open-weight coding model GLM-5.1 on the cluster, later upgrading smoothly to GLM-5.3.
Follow-up reporting by The Register revealed the bottom-line impact after the switch. Blended inference costs dropped to $0.30 per million tokens, and the monthly bill fell to just 10% of their previous commercial API spend. Across the engineering org, coding time dropped by 60%, and overall delivery lead time shrank by 70%.
Why did switching to an open-weight model that trails frontier models on paper benchmarks accelerate overall delivery even faster than coding itself? It had nothing to do with raw model intelligence. The billing model changed how engineers behaved every day.
When compute and code were expensive, every engineer carried an invisible price list in their head. As I noted in Disposable Software and Compressed Reality, writing a custom tool for a 10-minute debugging session used to be an unthinkable luxury. Engineers had to sample 10 random records and guess from intuition. Once the marginal cost of generating code approaches 0, spending 2 minutes to spin up a throwaway diagnostic web page becomes the optimal play.
When an API charges per token and enforces quota caps, that invisible price list snaps right back into place. After Revolut introduced personal budget caps, engineers calculated every day whether their remaining allowance would last until the end of the month. Worried about running dry during end-of-quarter sprints, they hoarded tokens like ration stamps, saving AI strictly for the hardest algorithmic problems.
That penny-pinching directly bottlenecked team output. As David Abitbol pointed out in his talk, the hours spent writing core algorithms are rarely what stalls delivery lead time. Combing through inboxes, routine debugging, filling out Jira tickets, and writing Confluence documentation swallow far more engineering hours.
As long as the meter is running, nobody burns precious quota on chores. Once the company switched to a self-hosted, fixed-cost GPU pool, the compute was already paid for upfront. Whether an engineer runs an extra 1 million tokens today to clean up documentation or not, the company’s bill at the end of the month does not go up by a single cent.
Freed from the psychological weight of the taxi meter, engineers started throwing AI at their entire inbox, Jira backlog, and Confluence docs without guilt. Unblocking those non-coding bottlenecks cut overall delivery lead time by 70%, easily outpacing the 60% reduction in raw coding time.
A fixed-cost pool also reshaped the rhythm of human-AI collaboration. Under metered billing, engineers stared at every line of streaming reasoning on screen, terrified the model would wander off track and waste money. With compute uncapped, engineers kick off multiple parallel jobs, move on to other work, and come back later to review the results. During daytime peak hours, generating 200 tokens per second per user is plenty; after 5 p.m., as interactive users sign off and background batch jobs take over, per-user throughput surges to 800 tokens per second.
The dividend of a fixed-cost pool raises an obvious question: if the flat-rate mindset is what unlocks productivity, why didn’t Revolut simply buy every engineer a $200-a-month commercial subscription? Conversely, should individual developers go out and buy their own GPUs?
To do the math, it helps to separate how LLM inference is procured. As I broke down in The Term “Local LLM” Conflates Two Distinct Markets, buying inference actually spans two independent dimensions: whether you have access to open weights, and whether you pay a flat time-based fee or per token. Self-hosting on your own GPUs and paying $80 a month for a Zhipu plan or $100 for an Ollama subscription sit in the exact same quadrant.
None of them tick per token, yet individuals and thousand-engineer enterprises reach that quadrant from opposite directions. For solo developers and small teams, buying multiple GPUs to run a local server at home is a money-losing proposition. I previously ran the numbers on the triple-RTX 5090 rig under my desk, which runs a 4-bit quantized Qwen3.8-27B model on roughly $17,000 of hardware.
At roughly $350 in monthly depreciation, the rig has to run at full load 24/7 just to push the cost down to $0.40 per million tokens. Because I only actively use it for an hour or two a day, actual utilization sits below 5%—nowhere near the 26% to 45% break-even threshold. Amortized over real usage, each million tokens costs $4 to $6, nearly 10x the price of commercial APIs. For an individual, a local rig is like keeping a diesel generator in the backyard: you buy it to keep data on-premises, not to save money.
For individual developers looking for sustained daily use, buying a commercial subscription is by far the best deal. I examined the subsidy mechanics behind this in The Five Ledgers of AI Costs. A heavy user paying a $200 monthly subscription can easily consume $2,000 to $5,000 worth of list-price compute. Model labs willingly eat that 10x to 25x subsidy because they are effectively recruiting senior developers to generate high-value interaction traces on hard problems for future training runs.
Because model weights depreciate and get replaced roughly every 6 months, labs rely on metered enterprise APIs—where gross margins reach as high as 85.4%—to recoup costs. To stop enterprises from treating consumer subscriptions as bulk APIs, providers erected strict restrictions like The Claude Price Fence, blocking subscription accounts from third-party clients and programmatic calls. Large enterprises are locked out of consumer subscription pricing and cannot collect those flat-rate subsidies from model vendors.
Fortunately, once a team crosses the thousand-engineer mark, the laws of hardware utilization flip in its favor. Revolut shares 56 GPUs across 2,000 engineers—an average of roughly 36 engineers per GPU. A single developer types for a few minutes and pauses for half an hour to think or read. Stacking the reading gaps, debugging pauses, and evening batch jobs of 36 engineers onto a single card smooths out spiky, bursty demand.
Statistical multiplexing pushes hardware utilization well past the break-even line. Because commercial labs refuse to sell cheap flat-rate plans to large enterprises, Revolut self-hosted open-weight models and used a 36:1 multiplexing ratio to issue its own internal all-you-can-eat subscription card.
Removing quota caps and letting everyone submit jobs in parallel inevitably triggers a traffic spike. Without continuously buying more GPUs, how do you keep 2,000 engineers from grinding the cluster to a halt? That is the engineering hurdle every self-hosted flat-rate pool has to clear.
When Revolut first deployed GLM-5.1 on 56 B200s in April 2026, the out-of-the-box configuration performed poorly. At roughly 3 requests per second, time to first token (TTFT)—the delay between hitting Enter and seeing the first character appear on screen—hit a painful 14.26 seconds. Their internal rule of thumb was simple: if TTFT exceeds 5 seconds, Slack floods with complaints; it had to stay under 3 seconds.
Between April and August, internal request volume climbed another 76% to more than 7 requests per second. The team imposed a hard constraint on themselves: hold the cluster at exactly 56 B200s without adding a single GPU. Through systematic tuning, they slashed TTFT by 88%, bringing it down to 1.68 seconds.
Why did 56 top-of-the-line GPUs choke to over ten seconds right out of the gate? The bottleneck was VRAM contention. Alongside roughly 380GB of model weights, the GPUs have to store the conversation history for every active coding session so the model does not re-read the entire codebase on every follow-up turn—a dedicated memory region known as the KV cache.
A single engineer’s conversation cache can consume 6GB to 26GB of VRAM. With hundreds of engineers holding long sessions open simultaneously, memory runs out fast. To free up room for concurrent caches, the team first killed the 1-million-token context gimmick. Although the model supports a 1M context window, Abitbol called it a VRAM trap that blows up concurrent queues. Testing showed 256K tokens was more than enough for coding workflows, so they locked in that hard ceiling.
Next came weight quantization and wider tensor parallelism. Switching from 8-bit weights to native 4-bit floating-point compression (NVFP4) freed 40% of VRAM without quality loss. Even though the compressed weights fit onto 4 GPUs, they deliberately sharded each model instance across 8 GPUs, leaving generous headroom on every card for concurrent KV caches.
They also kept prefix-cache hit rates—reusing cached state when prompts share identical leading code context—above 90%. By disaggregating prefill (reading long prompts) and decode (generating tokens one by one) onto separate GPUs, and layering in chunked prefill and speculative decoding, they drove latency down even further. Once single-model optimization was maxed out, they routed tasks unsuited for a text-only coder elsewhere: screenshot queries go to Gemini or GPT Luna, designers use vision-capable GLM-5V-Flash, and the hardest edge cases route through an exception path to Claude Code or Codex.
Beyond compute and latency, a financial institution has to clear strict compliance and security bars: how can a heavily regulated EU bank run an open-weight model released by a Chinese lab? The regulatory red line isn’t the nationality of the weights—it’s sending source code and customer data outside the perimeter to third-party APIs. Revolut runs its open-weight servers inside zero-data-retention (ZDR) data centers across the US, EU, UK, and Israel, keeping every byte inside its compliance boundary.
EU banking rules are even stricter when it comes to autonomous
agents. Revolut wraps execution in a command sandbox that auto-approves
safe read/stage operations like grep and
git add, but intercepts build-mutating commands like
gradle until a human clicks approve. Pairing
human-in-the-loop confirmation with full audit logging keeps the system
firmly classified as a human-assisted tool under regulatory
frameworks.
Before copying Revolut’s playbook, we need to lay out the unstated caveats behind these numbers. The 60% coding speedup, 70% delivery lead-time reduction, and $0.30 per-million-token figure are all company self-reported and have not been independently audited. Moreover, because Revolut swapped models and removed personal quota caps at the same time, there is no way to cleanly isolate how much of the gain came from the model change versus uncapping usage.
More importantly, the headline numbers only capture the tip of the iceberg. That $0.30 per million tokens and the 90% bill reduction reflect only marginal operating cost. The multi-million-dollar hardware depreciation or rental commitment for 56 B200 GPUs—and the salaries of the dedicated inference engineering team that tuned TTFT from 14.26 seconds down to 1.68 seconds—are left out of the denominator.
With those boundaries in view, teams of different sizes can make a clear-eyed choice. If you are an individual developer or an engineering team under a hundred people, do not let a headline 90% cost reduction tempt you into buying GPUs or renting bare metal. Your concurrency won’t keep the cards utilized, and you can’t justify a dedicated inference tuning team. Buying commercial monthly subscriptions or flat-rate cloud plans for open-weight models—simply turning off the API taxi meter—remains the most cost-effective play today.
If you run a thousand-person engineering organization and are tired of fighting over metered API bills and token quotas, Revolut points the way forward. The real dividend of enterprise self-hosting is combining a heavily multiplexed fixed-cost compute pool with open weights to recreate the flat-rate subscription experience internally. Rip the taxi meter out of your engineers’ heads first—that is when AI productivity actually shows up.