Mykyta Bulatnikov
← Back

Founder, sole engineer · 2026 — now

Skriptly — an AI transcription product, rebuilt until it was fast and cheap

Transcription and dictation I built and run solo. I rebuilt the engine twice: a hosted API, then open-source models on GPUs, then Soniox. Better accuracy, 4× cheaper.

60+
languages, auto-detected
2.4%
word error rate, down from 3.7%
4×
cheaper per hour than self-hosted GPUs

Why I built it

I wanted my own work calls to turn into clean notes without me doing anything. Everything on the market handled English well and fell apart on the mix I actually work in: Ukrainian, Russian, Czech, Polish and English, sometimes in the same call. So in May 2026 I started building the tool I wanted, and I have run it as a product since: a web app, a Windows app, accounts and subscription plans. It is in private beta with a limited group of testers.

You record or upload a call and get a transcript with a label on every speaker, a summary and action items. A hold-to-talk dictation mode types into any Windows app. I do all of it myself: the audio pipeline, the backend, the web and desktop apps, billing, pricing and support.

What it looked like, and what it looks like now

First version. A small app on Railway that sent audio to a hosted speech-to-text API. It worked, and it was a prototype: no accounts, no history, and no control over quality or cost.

Second version: my own pipeline from open models. By June 2026 it was a proper product on Modal’s serverless GPUs. faster-whisper (large-v3) produced the words, pyannote worked out who spoke, a wespeaker model matched voices, and an LLM fixed phonetic errors. A three-hour workshop was cut at silences into chunks, transcribed in parallel on several GPUs and stitched back together, with a clustering step that keeps “Speaker 2” the same person in the ninth chunk as in the first. Per-user vocabulary was fed back into the next transcription. It was good engineering, and it was expensive and slow to keep right: GPU cold starts, gigabytes of models to host, and an error rate I could only push down by tuning.

Now: Soniox. In September I benchmarked it against my own pipeline on a reference set in five languages (Ukrainian, Russian, Polish, Czech, English), clean and phone-quality, and on a real 54-minute call with four speakers.

open-source pipelineSoniox
word error rate3.7%2.4%
words dropped1.3%0%
cost per audio hourabout $0.41$0.10

It also produced cleaner turn boundaries on the long call, so I moved the whole product to it. The GPU pipeline stays in the codebase as a fallback for very long files and a possible privacy mode.

Switching was not just swapping a vendor. Soniox cannot be told how many people are in a call and sometimes confuses similar voices, so I added a step that re-labels speakers by voice embedding when the user tells me the headcount. And because it bills by the length of each audio track, I trim long silences out of the microphone track before sending it and map the timestamps back afterwards.

Dictation, and why it is fast

The Windows app is a small Rust (Tauri) program that lives in the tray: hold Ctrl+Win, speak, release, and the cleaned text is pasted wherever the cursor is. In my own daily use it is faster than Wispr Flow, and the reasons are architectural rather than magic:

  • No server in the audio path. The app streams audio straight to Soniox over a WebSocket using a short-lived key, so there is no backend hop and no cold start. My backend only sees usage counts and the text to polish.
  • The microphone is already open. An “instant start” mode keeps it open with a half-second pre-roll, because a Bluetooth headset otherwise loses the first half-second of speech while it switches modes.
  • Polish in about a second. One Gemini 2.5 Flash call with thinking switched off removes filler words and applies self-corrections. If the model answers or translates instead of cleaning, a check throws its output away and keeps the original text.
  • It learns from your edits. After pasting, the app reads the same field through Windows UI Automation, waits until you stop editing, and sends only the change. The server turns it into wrong-to-right pairs for your vocabulary. It never reads password fields.

Cost is a feature

I track what an hour costs me: about $0.30 for a call and $0.20 for an uploaded file, and about $0.03 per thousand words of dictation. That number made two decisions for me. LLM-generated titles ran on a GPU and cost more than the transcription of a half-hour call, so I switched them off and use the first words instead. A live transcript during recording was built and worked, and doubled the cost of an hour, so I switched that off too. The code stays behind a flag.

Billing runs through Stripe. There is a Free plan, a Pro plan and a Team plan with a shared pool of minutes.

What I learned shipping it

A production capture fault lost the remote speakers on headphone setups. The recording sounded fine and was missing half the conversation. A user found it, not I. Since then every capture records telemetry (is there tab audio, levels, seconds of silence per channel, device changes), and there is an admin page where I can listen to each channel of a recording separately next to the raw transcript.

Quality is a number, not an impression. An evaluation set measures word error rate and how often words get deleted, which is what made the Soniox decision possible, and what stops tuning from turning into guessing.

Where it goes next

  • macOS. The platform layer in the app is already split out; the Mac build has not been compiled yet.
  • Training on corrections. Stored wrong-to-right pairs only bias the decoder through the prompt. They are also training data for the languages where off-the-shelf models are weakest.
  • Search across the archive. The transcripts already sit in Postgres, so finding the call where a decision was made is embeddings over data that exists.
  • Python
  • Flask
  • Modal
  • Soniox
  • faster-whisper
  • pyannote
  • Gemini API
  • Next.js
  • Rust (Tauri)
  • Supabase
  • Stripe
  • PostHog