You upload a meeting recording — the system instantly detects the language, launches faster-whisper on GPU, and delivers a ready transcript with speaker diarization in 5-10 minutes. But that's only half the job. Without a web interface, you can't correct errors, add annotations, or export to the required format. We build a complete solution: upload, background recognition, interactive editor, and export. Such a product can be used as an internal service or launched as a SaaS.
How AI transcription with a web interface works
Backend on FastAPI receives the file, queues the task via Celery and Redis, a worker with faster-whisper on GPU processes the audio, and the result is stored in PostgreSQL. Frontend on React polls the status and displays the transcript. The entire pipeline — from upload to export — takes as little as 5 minutes for a one-hour recording. The key component is faster-whisper, which provides a 4x inference speedup over the base Whisper.
Problems we solve: speed, accuracy, confidentiality
The first pain point — poor quality on noisy recordings or multi-speaker conversations. We use faster-whisper with noise suppression, which reduces WER (Word Error Rate) by 15–20% compared to base Whisper. The second issue — latency under growing load. The Celery and Redis architecture enables horizontal scaling of workers. The third — security: audio may contain sensitive data, so we encrypt everything at rest and in transit. faster-whisper is the key component, delivering up to 4x inference acceleration — 4 times faster than the original Whisper model.
What fine-tuning Whisper gives
The base Whisper model achieves 92–95% accuracy on general Russian speech. If your domain is medicine, law, or technical documentation, fine-tuning on your data pushes accuracy to 98%. We fine-tune the model on a dataset of 100–500 hours of labeled audio recordings. The average cost of such a dataset varies, but it typically pays off in 2–3 months due to reduced manual corrections. Our experience shows that after fine-tuning, errors in specific terms drop by 2–3 times.
How we build the system
We design the solution according to your load. Below is the stack we use in most projects:
- Backend: FastAPI + Celery + Redis
- Frontend: React + TypeScript + Tailwind
- STT: faster-whisper (GPU) + cloud fallback
- Storage: S3 (MinIO for on-premise)
- DB: PostgreSQL
Backend API (example):
from fastapi import FastAPI, UploadFile, BackgroundTasks
from celery import Celery
import uuid
app = FastAPI()
celery = Celery('transcription', broker='redis://localhost:6379/0')
@app.post("/api/transcription/upload")
async def upload_audio(
file: UploadFile,
language: str = "ru",
speakers: int = None,
user_id: str = Depends(get_current_user)
):
job_id = str(uuid.uuid4())
file_path = await save_to_storage(file, job_id)
job = await db.transcription_jobs.insert_one({
"id": job_id,
"user_id": user_id,
"status": "queued",
"file_path": file_path,
"language": language,
"created_at": datetime.utcnow()
})
celery.send_task(
'transcribe_audio',
args=[job_id, file_path, language, speakers]
)
return {"job_id": job_id, "status": "queued"}
@app.get("/api/transcription/{job_id}")
async def get_transcription(job_id: str, user_id = Depends(get_current_user)):
job = await db.transcription_jobs.find_one({"id": job_id, "user_id": user_id})
if not job:
raise HTTPException(404)
return job
React upload component:
const TranscriptionUploader: React.FC = () => {
const [status, setStatus] = useState<'idle'|'uploading'|'processing'|'done'>('idle');
const [jobId, setJobId] = useState<string>();
const [transcript, setTranscript] = useState<string>();
const handleUpload = async (file: File) => {
setStatus('uploading');
const form = new FormData();
form.append('file', file);
form.append('language', 'ru');
const { job_id } = await api.post('/transcription/upload', form);
setJobId(job_id);
setStatus('processing');
const interval = setInterval(async () => {
const job = await api.get(`/transcription/${job_id}`);
if (job.status === 'completed') {
setTranscript(job.transcript);
setStatus('done');
clearInterval(interval);
}
}, 3000);
};
return (
<div>
<FileDropzone onFile={handleUpload} accept="audio/*,video/*" />
{status === 'processing' && <ProgressSpinner jobId={jobId} />}
{transcript && <TranscriptEditor text={transcript} jobId={jobId} />}
</div>
);
};
Comparison: self-hosted vs cloud STT
| Parameter | Self-hosted (faster-whisper) | Cloud (e.g., Speech-to-Text) |
|---|---|---|
| Price per 1 hour of audio | significantly cheaper (electricity only) | more expensive (from $2) |
| Confidentiality | full control | data leaves the server |
| Latency p99 | <10 sec | 50–200 ms + network |
| Scaling | limited by hardware | elastic |
| Custom model | yes (fine-tuning) | no |
The self-hosted option pays off at volumes from 500 hours per month: savings reach 90–95%. At 1000 hours per month, cloud STT would cost $2000, while self-hosted only the cost of electricity and GPU depreciation (T4 or A10). This saves up to $1900 per month. Guarantee of stable operation — our implementation experience in 12 projects.
Transcript editor and export
In the editor you can correct words, reassign speakers, add annotations. Highlighting low-confidence words (confidence < 0.7) speeds up review. Export formats:
| Format | Use case |
|---|---|
| SRT | Subtitles for video |
| VTT | Web subtitles (HTML5) |
| DOCX | Documentation, reports |
| JSON | Integration with CRM |
Project stages
- Requirements analysis — gather scenarios, accuracy requirements, volumes, security needs.
- Architecture design — select optimal stack for your infrastructure.
- Backend development — implement upload API, task queue, processing via faster-whisper.
- Frontend development — upload interface, status bar, transcript editor.
- Integration and testing — connect CRM, perform load testing.
- Deployment and support — deploy on servers, documentation, team training.
Deliverables: what is included in the result
- Architecture diagram
- Repository with backend and frontend
- CI/CD and infrastructure setup (Docker Compose / Kubernetes)
- Integration with corporate portal or CRM
- Technical documentation and user manual
- Team training (1–2 sessions)
- 2 weeks of post-launch support
Estimated timelines
- MVP with upload and basic interface — 2–3 weeks
- Full system with editor, team features, and fine-tuning — 1.5–2 months
How to avoid common mistakes
- Poor audio quality (noise, overlap) — solved with denoising preprocessing.
- High latency — optimize batch processing and GPU utilization.
- Missing speaker diarization — apply voice embedding clustering.
- Data leakage risk — encryption and on-premise deployment.
Contact us for a project assessment. Order a custom transcription system development. Get a consultation today.