Rutube moves from a Whisper pilot to its own subtitle platform and speech recognition

Rutube has described how it launched automatic subtitles for user-generated video: first through a quick pilot on Whisper, then through its own ASR platform. The team got there after realizing that recognizing speech in a demo and reliably processing the entire content stream are two very different tasks.

Why Whisper wasn't enough

At the start, Whisper was a convenient way to test the hypothesis. It let the team quickly assemble a first service, put subtitles into production and confirm that users actually need the feature. But after launch, limitations surfaced that are hard to see during a pilot: the platform receives millions of new videos, some of them up to 24 hours long, the audio can be noisy, and the language is not known in advance. On top of that come requirements for text quality and tight limits on processing speed, because subtitles must appear not at some point later, but within the working rhythm of the service.

Between "recognizing speech" and "making subtitles for all content"

lies a huge layer of work.

This gap became the team's main takeaway. For user-generated video, it is not enough to run the audio track through an off-the-shelf model and save the result. You need all the scaffolding around recognition: handling long files, resilience to poor audio, text quality control, queue management and predictable performance under heavy load. Otherwise even a good ASR model becomes a bottleneck that cannot withstand industrial load.

What the system grew into

In the end, the task stopped being "one more service built on ASR" and turned into a full subtitle platform. Rutube says this required moving to a microservice architecture and its own speech recognition system. The approach is not about a fashionable stack but about separation of responsibilities: one part of the system ingests and prepares video, another does the recognition itself, a third assembles and delivers the result. At large volumes this is critical, because it allows individual components to scale independently and keeps the whole pipeline from collapsing when one spot is overloaded.

Such a platform has to meet several requirements at once:

• Ingest a stream of millions of new videos without manual involvement
• Process videos up to 24 hours long without breaking the pipeline
• Work with an unknown language and noisy user audio
• Keep text quality high enough for publication
• Stay within limits on processing speed and cost

Moving to its own ASR looks logical in this context. When a product runs on mass-scale UGC, a general-purpose external model helps get started but is poorly suited to fine-tuning for real data, infrastructure constraints and target metrics. Its own system gives more control over speed, quality, resources and how exactly recognition behaves on hard cases, which for a video platform become the norm rather than the exception.

How the speed was achieved

The most striking figure in Rutube's story is throughput of about 1200 videos per hour per ASR. It is an important benchmark, because in production, recognition quality cannot be considered separately from throughput. If a system produces good text but accumulates a queue of thousands of videos, the user gets little benefit. If the pipeline is fast but unstable on long videos or poor audio, the product starts breaking again in real operation. That is why the architecture matters as much as the model itself.

Behind this figure is not one clever algorithm but a series of engineering decisions: how to cut and feed audio, how to distribute tasks, how not to waste time on inefficient stages and how to keep resources under control. The economic side matters too. The higher the throughput per ASR instance, the easier it is to scale the service without an explosive rise in infrastructure costs. For platforms with a constant UGC stream, this is no longer a question of convenience but the basic economics of the product.

What this means

Rutube's story clearly shows the line between a quick AI prototype and a mature product. An off-the-shelf model like Whisper helps you start fast, but a mass-scale service requires its own architecture, quality control and optimization for real loads. For anyone building AI features on top of user content, this is a direct signal: the bottleneck is usually not in a single model but in the whole pipeline around it.