How I Cut AI Transcription Costs Below $0.10/Hour with AWS Spot Instances and Whisper Large-v3 Turbo

A solo developer rebuilt an AI transcription pipeline on AWS using Spot Instances, SQS queue-based autoscaling, and Whisper Large-v3 Turbo, cutting processing costs below $0.10 per hour—cheaper than the OpenAI Whisper API. The architecture, which powers the StrikeScribe platform, scales GPU workers to zero when idle and uses faster-whisper with int8_float16 quantization to reduce compute and memory usage.

A deep dive into building a cost-optimized, self-hosted AI transcription pipeline on AWS - using Spot Instances, SQS queue-based autoscaling, and Whisper Large-v3 Turbo - that beats the OpenAI Whisper API on price. Most teams building on top of speech-to-text quietly accept the API bill. I didn't. When a side project started costing me $180/month in transcription API fees , I rebuilt the entire pipeline on AWS and got my processing cost below $0.10/hour - cheaper than the OpenAI Whisper API itself. This post walks through the architecture, the trade-offs, and the specific decisions that made it work. Everything here powers StrikeScribe https://www.strikescribe.com , the AI transcription platform I built as a solo founder, so these numbers come from real production workloads, not a benchmark toy. If you're building anything on top of Whisper, Deepgram, AssemblyAI, or the OpenAI audio API, this is the arbitrage most people miss. Managed APIs are fantastic for getting started. You send audio, you get text. But the pricing model punishes volume: The moment you're processing hundreds of hours a month — meetings, podcasts, research calls, IoT audio streams — that linear cost curve becomes the dominant line item. You're paying a margin on GPU compute you could rent directly. The insight: the underlying model Whisper is open source. You're paying for someone else's convenience layer. If you can run the inference yourself efficiently, the economics flip. Here's the high-level pipeline: Upload → S3 → SQS Queue → Autoscaling Worker Group GPU Spot Instances → Whisper Large-v3 Turbo → Pyannote diarization → Postgres → Client Let me break down the parts that actually matter for cost. Whisper Large-v3 Turbo gives you near-Large-v3 accuracy at a fraction of the inference time. For a cost-sensitive pipeline, inference speed is cost, because you're paying for GPU-seconds. Turbo dramatically cuts the seconds-per-audio-hour ratio. For faster throughput, I run it via faster-whisper CTranslate2 backend , which is significantly more memory- and compute-efficient than the reference implementation: python from faster whisper import WhisperModel int8 float16 keeps VRAM low while preserving accuracy model = WhisperModel "large-v3", device="cuda", compute type="int8 float16", segments, info = model.transcribe "audio.wav", beam size=5, vad filter=True, skip silence, save compute vad parameters={"min silence duration ms": 500}, for segment in segments: print f" {segment.start:.2f} - {segment.end:.2f} {segment.text}" Two cheap wins here: vad filter=True int8 float16 quantizationThe naive approach is one always-on GPU instance. That's the expensive approach — you pay for idle time. Instead, I decouple upload from processing with an SQS queue . A lightweight Node.js controller polls the queue depth and scales the worker fleet based on backlog: js import { SQSClient, GetQueueAttributesCommand } from "@aws-sdk/client-sqs"; import { AutoScalingClient, SetDesiredCapacityCommand } from "@aws-sdk/client-auto-scaling"; const sqs = new SQSClient { region: "us-east-1" } ; const asg = new AutoScalingClient { region: "us-east-1" } ; async function scaleWorkers { const { Attributes } = await sqs.send new GetQueueAttributesCommand { QueueUrl: process.env.QUEUE URL, AttributeNames: "ApproximateNumberOfMessages" , } ; const backlog = parseInt Attributes.ApproximateNumberOfMessages, 10 ; // one worker per N queued jobs, capped to control spend const desired = Math.min Math.ceil backlog / 5 , MAX WORKERS ; await asg.send new SetDesiredCapacityCommand { AutoScalingGroupName: process.env.ASG NAME, DesiredCapacity: desired, } ; } When the queue is empty, the fleet scales to zero GPU workers. You pay for GPU time only when there's audio to process. That's the single biggest structural cost lever. GPU Spot Instances are 60–90% cheaper than on-demand. The catch: AWS can reclaim them with a 2-minute warning. For a stateless batch workload like transcription, this is a perfect fit — if you handle interruptions gracefully. The worker listens for the Spot interruption notice and requeues its in-flight job so nothing is lost: // Poll the instance metadata endpoint for the interruption signal async function checkForInterruption { try { const res = await fetch "http://169.254.169.254/latest/meta-data/spot/instance-action", { signal: AbortSignal.timeout 1000 } ; if res.status === 200 { // Reclaim imminent — put the current job back on the queue await requeueCurrentJob ; await gracefulShutdown ; } } catch { // 404 = not interrupted, carry on } } setInterval checkForInterruption, 5000 ; Because jobs are idempotent and queue-backed, an interrupted job simply gets picked up by another worker. No lost work, no manual recovery. This resilience is what makes Spot viable for production, not just for hobby batch jobs. Raw transcript is only half the value — knowing who said what is what turns a wall of text into usable meeting notes. Pyannote handles speaker diarization: python from pyannote.audio import Pipeline pipeline = Pipeline.from pretrained "pyannote/speaker-diarization-3.1", use auth token=HF TOKEN, diarization = pipeline "audio.wav" for turn, , speaker in diarization.itertracks yield label=True : print f"{speaker}: {turn.start:.1f}s - {turn.end:.1f}s" You then align diarization segments with Whisper's timestamps to attribute each line to a speaker. It adds compute, but it's the difference between "a transcript" and "meeting intelligence." Running this pipeline in production: The compounding effect of the four levers — Turbo model, VAD silence-skipping, scale-to-zero autoscaling, and Spot pricing — is multiplicative, not additive. Each one alone helps; stacked, they change the entire unit economics. To be fair, this isn't free lunch. Self-hosting made sense for me because: If you're doing low volume, need sub-second live captioning, or don't want to babysit infrastructure, a managed API is genuinely the right call. The break-even point is usually somewhere in the low hundreds of hours per month. The arbitrage model — find what competitors overprice, then build it cheaper on primitives you control — is very real in AI infrastructure right now. A huge amount of "AI product" pricing is just margin on top of GPU compute and open models. If you're processing meaningful audio volume, the stack that worked for me was: faster-whisper + Large-v3 Turbo with int8 float16 and VADI baked all of this into StrikeScribe https://www.strikescribe.com — upload audio or video, get a searchable transcript plus structured AI insights, no signup and no meeting bot required. If you want to see the output side of this pipeline in action, that's the easiest way. Happy to answer architecture questions in the comments — especially around Spot interruption handling and diarization alignment, which are the two things people usually get stuck on.