T09-L04 · Create media · Level 4 Integrator · 18-minute read, plus 4 hours of doing

A psychology group at a university clinic runs an interview study with 120 outpatients. Each interview takes about an hour. A PhD student transcribes them by hand, at five to six hours per interview, and she is on number 23. Someone at the group meeting mentions the caption pipeline the institute built last spring: why not send the interviews through it? The PI, the professor who leads the study, looks up the consent form. Participants agreed that their recordings are "stored and processed only on systems of the institute". The hosted service is out.

The obvious next idea is to run the same speech model on the group's own computer. That's the right idea, and it's where people go wrong. A "local" model on a workstation whose data drive the whole department can read, that downloads files from the internet as it runs, and that keeps copies of the audio in a folder nobody deletes, isn't what the consent form promised.

In a company it's a medical-device maker's customer hotline. Calls about faulty devices are recorded, and each one has to become a complaint file. The calls contain patients' health details and the voices of the hotline staff.

You are at Level 4 Integrator. You're connecting a model to real recordings of real people, on your organisation's systems. This book shows you how to do that so the promise in the consent form stays true.

After this you can

  • Decide with three checks (fits, fast enough, worth running) whether a local speech model beats an approved hosted service for your recordings.
  • Write a one-page data route and get it signed by the data protection officer, IT and, where they are involved, the ethics committee or works council.
  • Run a pinned Whisper model on a workstation that can't send audio out, through a job account that reads one folder and writes one other.
  • Keep a way back: originals untouched, every draft reviewed by a named person, and a tested procedure to stop the job, delete audio on schedule and redo a draft.

Before you start

Last verified 23 September 2026. faster-whisper and the Whisper large-v3 model are free under the MIT licence. On a card with 8 GB of memory, 13 minutes of audio take about a minute. OpenAI's hosted Whisper costs $0.006 a minute. Details for experts at the end of this book.

The idea in one page

Local isn't the same as controlled. A recording counts as "staying in the building" only when you can answer four questions:

QuestionWhat a good answer looks like
Where does the audio sit?One named folder on a server IT backs up, not a desktop or a USB stick
Who and what can read it?The people named in the approval, plus one job account for the transcription, nothing else
Where can it go?Nowhere: the job runs with no route to the internet, and the model files are already on the machine
When is it deleted?On the date the consent form or agreement sets, by a named person, with a line in a deletion log

A job account is a user account that belongs to a task, not a person: here, the account the transcription runs under. Give it the smallest access that does the job, which is called least privilege: read the incoming folder, write the drafts folder, and nothing else. If the script has a bug, or someone copies it and points it somewhere else, the account's rights set the limit of the damage.

Three checks before you commit. Run them in this order, on your own hardware, with your own test clips.

  1. Fits? A model has to fit into the graphics card's own memory, called VRAM, with room to spare. The download size of the model files is only part of it. Measure the peak while it runs.
  2. Fast enough? Measure how long an hour of audio takes. The real-time factor is processing time divided by audio length: 0.1 means an hour of audio takes six minutes. Speed only counts for transcripts that pass the check.
  3. Worth running? A local model costs you a machine, updates and your time. If your data protection officer would approve a hosted service with a contract for your recordings, that is usually cheaper and less work. Self-hosting wins when the recordings must not leave, when the volume is large and steady, or when you must work offline.

Every draft is a draft. Whisper writes fluent text even where it's wrong, and it can invent whole sentences in long silences. A named person who knows the recording checks every transcript before it's used, exactly as in T09-L03 · Build a Caption Pipeline Your Team Can Rerun Every Week.

The people responsible sign, before the first real recording. The data protection officer (DPO) confirms the route fits the law and the consent. IT confirms the machine, the accounts and the network rule. Where the recordings are covered by an ethics approval, the ethics committee's conditions apply; where employees' voices are recorded, so do the works council's, the elected staff body that has to agree before a system can monitor employees. You write the one-page route; they sign it.

Keep a way back. The original recording is never changed. A draft can be deleted and made again as long as the audio exists. Deleting the audio is planned, logged and done by a person, never by the script.

Worked example: two recording routes, four quadrants

Both versions follow the four quadrants from T01-L01 · From Idea to Working Result: The Four-Quadrant Method. The lab one is told in full. Names, numbers and dates are illustrations.

Lab: interviews with outpatients

Structure it. Lena, the PhD student, writes the problem down with the PI. "120 interviews in German, 45 to 75 minutes each, stored on the institute's research server. Hand transcription takes 5 to 6 hours each. A useful result: a draft with timings that the interviewer corrects in about 90 minutes, made without the audio leaving institute systems, and deleted when the consent form says."

Understand it. She starts with the paperwork. The ethics approval repeats the consent form's sentence and adds a second one: audio is deleted "after transcription and quality control, at the latest at the end of the study". So the transcript becomes the research record, and the audio has an end date.

Then the machine. The group has a workstation that IT manages, with an NVIDIA card with 12 GB of VRAM, used for microscope images. She asks IT for a trial account and tries the model on the three scripted German test clips she recorded with a colleague, in the same folder layout as the T09-L03 · Build a Caption Pipeline Your Team Can Rerun Every Week pipeline, using the adapted check script shown under Build it below. The runtime is faster-whisper, a free program that runs the Whisper models about four times faster than OpenAI's original code, with less memory. She uses the large-v3 model.

The trial tells her three things, and only one is about the model.

  • The model is fine. The word error rates on the test clips, the share of words that differ from the known script, are 4% to 7%, and an interview's worth of audio takes about five minutes. The card peaks at about 5 GB.
  • On the first run the program downloaded the model files from Hugging Face, the website where open models are published, by itself. So the workstation can reach the internet, and so could anything running on it.
  • The workstation's data drive, where she had copied a test interview, is readable by all 40 accounts of the department.

And one thing about the model after all. In a test clip with a long pause, the draft contains "Vielen Dank fürs Zuschauen" ("thanks for watching"), a sentence nobody said. Whisper learned from subtitled videos, and it sometimes fills silence with the phrases that end them.

Back to Structure it. The model was never the hard part. "The audio stays in one folder on the research server that only the interviewers and one job account can read. The job reads from there and writes drafts to a second folder. The model files are copied onto the workstation once, and the job can't reach the internet. Silences are skipped, and the interviewer checks every draft against the recording. Audio is deleted after the check, by the interviewer, with a log line."

Choose tools. She goes through the three checks with her numbers. It fits: 5 GB of 12. It's fast enough: 120 hours of audio in about ten hours of machine time, overnight. Is it worth running? On cost alone, no: the hosted Whisper service would charge about $43 for all 120 hours. But the consent form rules the hosted route out, so the local route is the only one.

The alternative, for a Mac or a machine without an NVIDIA card, is whisper.cpp, another free program for the same models that runs on ordinary processors and Apple chips; it's slower.

If several groups later want transcription as a shared service instead of a script on one machine, start at Heidelberg AI Desk. Its catalogue lists LocalAI, a service you run on your own server that answers the same kind of requests as OpenAI's. Setting up a server for the whole institute is T11-L04 · Put Your Team's Assistant on a Server Colleagues Can Reach.

Build it: the data route, on one page. Before any real interview touches the workstation, she writes the route and sends it for signature.

DATA ROUTE · Outpatient interview study · v1 · 2026-10-02
Recordings   \\research-srv\OPI-study\incoming   (audio, never changed)
Drafts       \\research-srv\OPI-study\drafts     (written by the job only)
Approved     \\research-srv\OPI-study\approved   (written by interviewers only)
Read access  interviewers L. Brandt, M. Özkan, S. Wolf; PI; job account svc-transcribe
Processing   workstation PSY-WS07, managed by IT; no outbound internet;
             model files copied once, Whisper large-v3, revision edaa852
Job account  svc-transcribe: read incoming, write drafts, nothing else
Deletion     audio deleted by the interviewer after the transcript is approved;
             line in deletion-log.csv; at the latest 2027-12-31
On failure   job stops, nothing is published, audio untouched, IT and Lena told
Signed       DPO ______  IT ______  PI ______

The DPO asks two questions: is anything stored on the workstation itself, and who can see the drafts? Her answer is no, and the interviewers only. The DPO adds the route to the institute's record of processing, the list of every use of personal data that the GDPR requires, and signs. Because the processing stays on institute systems, as the approval says, the ethics committee doesn't need an amendment; the DPO notes that in her reply. IT signs after setting up the account, the folders and the network rule.

Build it: the machine. IT does three things and tells Lena how to check each.

First, the card. IT installs NVIDIA's driver and its CUDA libraries, the parts programs need to use the card; the versions faster-whisper expects are in Details for experts. Then nvidia-smi, NVIDIA's own tool for inspecting the card, prints its name, its memory and what's using it right now:

nvidia-smi

Second, the program and the model files, downloaded once, while the workstation still has its internet access for installation. Lena copies the T09-L03 · Build a Caption Pipeline Your Team Can Rerun Every Week pipeline folder to the workstation and, inside it, adds faster-whisper at one fixed version with uv, the tool from T09-L03 · Build a Caption Pipeline Your Team Can Rerun Every Week that keeps the pipeline's Python packages pinned:

uv add faster-whisper==1.2.1

Then this command fetches one exact version of the model (the long code is that version's identifier) into a folder on the workstation:

uv run python -c "from faster_whisper import download_model; download_model('large-v3', output_dir='D:/models/whisper-large-v3', revision='edaa852ec7e145841d8ffdb056a99866b5f0a478')"

Third, the network rule: IT blocks all outbound connections from PSY-WS07 except to the institute's own servers. Lena checks it by opening any public website on the workstation. It fails, as it should.

Build it: the script. In the copied pipeline folder she replaces the API call. The settings file now names a folder instead of a model name, so the script can't fetch anything:

# settings.toml
model_dir = "D:/models/whisper-large-v3"
model_revision = "edaa852ec7e145841d8ffdb056a99866b5f0a478"
compute_type = "float16"     # how precisely the numbers are stored; "int8_float16" needs less memory
glossary = "glossary.txt"
test_language = "de"
incoming = "//research-srv/OPI-study/incoming"
drafts = "//research-srv/OPI-study/drafts"
prompt = "Interview, Deutsch, Ambulanz. Begriffe:"
max_wer = 0.10

She asks OpenCode in Plan mode, as in T09-L03 · Build a Caption Pipeline Your Team Can Rerun Every Week, where it proposes a change before writing anything, for a transcribe_local.py that does what transcribe.py did, with the local model. After review:

"""Draft transcripts on this workstation. Nothing leaves it.
Run as svc-transcribe:  uv run transcribe_local.py"""
import csv, hashlib, os, pathlib, time, tomllib
os.environ["HF_HUB_OFFLINE"] = "1"   # the download library may not go online
from faster_whisper import WhisperModel

HERE = pathlib.Path(__file__).parent
S = tomllib.loads((HERE / "settings.toml").read_text(encoding="utf-8"))
IN, OUT = pathlib.Path(S["incoming"]), pathlib.Path(S["drafts"])
lines = (HERE / S["glossary"]).read_text(encoding="utf-8").splitlines()
glossary = [t.strip() for t in lines if t.strip() and not t.startswith("#")]
model = WhisperModel(S["model_dir"], device="cuda", compute_type=S["compute_type"])  # cuda = the NVIDIA card


def stamp(sec):
    h, rest = divmod(sec, 3600)
    m, s = divmod(rest, 60)
    return f"{int(h):02}:{int(m):02}:{s:06.3f}"


with open(HERE / "manifest.csv", newline="", encoding="utf-8") as fh:
    items = list(csv.DictReader(fh))
for item in items:
    audio, draft = IN / item["audio_file"], OUT / f"{item['item_id']}.vtt"
    if draft.exists():
        continue  # never overwrite a draft
    terms = ", ".join(glossary + [t for t in item["expected_terms"].split("|") if t])
    start = time.perf_counter()
    segments, info = model.transcribe(str(audio), language=item["language"],
                                      vad_filter=True, initial_prompt=S["prompt"] + " " + terms)
    cues = [f"{stamp(s.start)} --> {stamp(s.end)}\n{s.text.strip()}\n" for s in segments]
    rtf = (time.perf_counter() - start) / info.duration
    draft.write_text("WEBVTT\n\n" + "\n".join(cues), encoding="utf-8")
    fingerprint = hashlib.blake2b(audio.read_bytes(), digest_size=16).hexdigest()
    with open(OUT / "review-list.csv", "a", newline="", encoding="utf-8") as fh:
        csv.writer(fh).writerow([item["item_id"], item["reviewer"], fingerprint,
                                 S["model_revision"], f"{rtf:.2f}"])
    print(f"{item['item_id']}: draft for {item['reviewer']}, real-time factor {rtf:.2f}")

Three lines carry the Level 4 work. The first is HF_HUB_OFFLINE: it tells the download library behind faster-whisper never to go online, a second lock behind IT's network rule. The second is vad_filter=True, which switches on voice activity detection: the model skips the parts of the audio where nobody speaks, and with them most invented sentences.

The third is where the draft gets written: only after the whole interview is done, so a job that fails halfway leaves no half-finished file behind. The draft is in WebVTT, the caption format from T09-L03 · Build a Caption Pipeline Your Team Can Rerun Every Week, so each line of text carries its time and Subtitle Edit can jump to it. As before, the review list gets a fingerprint of the audio file, a short code that changes if the file changes, so every draft can be traced to the exact recording and model.

She changes check.py the same way: its API call becomes the local model, and the text of the returned pieces is joined into one string before it's compared with the script. The top of the file gets the same setup lines as transcribe_local.py (the offline setting, the import and the model), and these lines replace the block that opened the clip and called the API:

    segments, _ = model.transcribe(str(script.with_suffix(".mp3")), language=S["test_language"],
                                   vad_filter=True, initial_prompt=S["prompt"] + " " + ", ".join(terms))
    got = " ".join(seg.text for seg in segments)

She runs uv run check.py on the three test clips: 4.1%, 5.6% and 6.8%, all under the 10% limit she set in max_wer, and no lost terms. The pause clip now comes back without the invented sentence.

Understand it: prove the limits. A permission you haven't tested is a guess. With IT, she opens a command window that runs as the job account; Windows' runas command does that, and IT types the account's password:

runas /user:INSTITUTE\svc-transcribe cmd

In that window she tries four things. Listing the incoming folder with dir \\research-srv\OPI-study\incoming works. Writing a test file into the approved folder, echo test > \\research-srv\OPI-study\approved\test.txt, fails with Access is denied. Listing the department share with the microscope images fails the same way. And curl https://huggingface.co, which tries to fetch a web page, fails because the network rule blocks it.

She also runs her longest interview while NVIDIA's tool shows the memory in use every second:

nvidia-smi -l 1

The peak is 5.2 GB, which goes into the route as the measured value. Each result goes into a short test note next to the data route.

Build it: the run sheet for IT. One page, pinned in the pipeline folder, that says what happens when something breaks:

  • The job stops with an error: nothing is published and the audio is untouched. Read the last line of job.log in the pipeline folder. Out of memory means switching the compute type in the settings to the smaller int8_float16 and running the check again before any interview. File not found means the manifest and the folder disagree.
  • A draft is wrong in a way the check didn't catch: delete the draft, as long as the audio still exists; the next nightly run makes it again, because the script only skips items that already have a draft. Add a test clip that reproduces the problem.
  • Anything reaches the internet, or someone outside the list can read a folder: stop the scheduled job, tell IT and the DPO the same day, and don't restart until both agree.
  • Deleting audio: only after the transcript is in the approved folder, by the interviewer, with a line in deletion-log.csv: item, date, who.

IT sets up a task in Windows Task Scheduler, which starts a program at a set time under a given account, to run the job every night at 22:00 as svc-transcribe. The task runs cmd /c uv run transcribe_local.py >> job.log 2>&1, which adds every message and error of the run to job.log. Lena's colleague Mehmet runs the run sheet once without her: in Task Scheduler he right-clicks the task and chooses Disable to stop it, deletes a test draft, chooses Enable again and finds the draft back the next morning.

Build it: the first real week. Five interviews go through. Each interviewer opens their own draft in Subtitle Edit, corrects it against the recording, saves it into approved and deletes the audio with a log line. Correction takes 70 to 110 minutes per interview, against five to six hours by hand. Two drafts have a wrong drug name in the same place; she adds the name to the study's glossary.

What it taught her: the model took an afternoon. The route, the account and the deletion plan took two weeks, and they are what the consent form was about.

Company: calls to a medical-device hotline

Structure it. Tobias in the quality department writes: "About 300 complaint calls a month, 5 to 15 minutes each. Every one must become a complaint file within two working days. A useful result: a draft transcript the complaint specialist can check and quote from, instead of typing notes from memory."

Understand it. The calls are recorded by the company's phone system, which keeps them for 30 days. They contain patients' health details, which the GDPR treats as a special category that needs extra protection, and the hotline staff's voices. Two findings change the problem. The works council points out that transcripts of every call could be used to judge how each agent performs; under German law, a technical system that can monitor employees' performance needs its agreement. And the phone system's export would give the transcription job every recorded call in the company, not just the hotline. Back to Structure it: "Only hotline complaint calls, only for the complaint file, never to assess staff, and the job sees nothing else."

Choose tools. The same faster-whisper setup on a workstation in the quality department. At about ten minutes a call, the hosted service would cost about $18 a month, so cost isn't the reason. The reason is that the works agreement and the DPO want the audio to stay in the company's systems. IT sets up an export of the hotline queue only into one folder, which the job account can read.

Build it. The data route gets a works council line: "Transcripts are used only for complaint files. No evaluation of individual employees. Access: quality team. Deleted with the recording after 30 days unless part of a complaint file." The DPO confirms the data protection impact assessment, the written risk check the GDPR asks for when special categories are processed, covers it. The specialist attaches the checked transcript to the complaint record by hand; nothing writes into the quality system automatically. That's the way back: a wrong transcript never reaches a regulator's file without a person choosing to attach it. The run sheet adds one line: if the export ever contains calls from other queues, stop the job and tell IT.

In both cases the model was a download. What made the setup safe was knowing which folder it reads, which account it runs as, where it can't go and who deletes what, and having that signed.

What goes wrong

Local is taken for controlled. Symptom: the model runs on your machine, and the audio sits on a drive the whole department can read. Fix: answer the four questions (where, who, where to, when deleted) on one page, and have IT set the folder permissions before the first real recording.

The model downloads itself at run time. Symptom: the first run fetches files from the internet, so the workstation can reach it. Fix: download the pinned version once during setup, point the script at the folder, set HF_HUB_OFFLINE, and have IT block outbound connections.

Sentences nobody said. Symptom: a transcript contains a polite closing phrase in the middle of a pause. Fix: switch on voice activity detection, add a test clip with long pauses, and never skip the human check.

The job runs as you. Symptom: the scheduled task uses your account, which can read every project you work on. Fix: a job account with read on one folder and write on another, and a test that shows it can't read anything else.

Out of memory halfway through. Symptom: the job stops on long interviews after working on the test clips. Fix: measure the peak on your longest real recording, not the test clips. If it's close to the card's limit, use int8_float16 and run the check again.

Audio kept forever, or deleted too early. Symptom: recordings from a finished study still on the server, or audio deleted before anyone checked the transcript. Fix: delete only after approval, by a person, with a log line, and put the final deletion date from the consent form in the calendar.

Self-hosting because it feels safer. Symptom: a GPU workstation to maintain for seminar talks whose speakers agreed to a hosted service. Fix: run the third check honestly. Where an approved hosted service is allowed, it's usually cheaper and less work.

Do it yourself (4 hours, over two weeks)

  1. Structure it (20 min). Write who needs transcripts, how many hours of audio, how fast, and what the consent form, ethics approval or works agreement says about where the audio may go and when it's deleted.
  2. Understand it (60 min). With a trial account from IT, copy your T09-L03 · Build a Caption Pipeline Your Team Can Rerun Every Week pipeline folder to the workstation, add faster-whisper and the model files as in Build it: the machine, change check.py as shown in Build it: the script, and run it on your test clips. Note the error rates, the peak memory, the time, and what the machine can reach and who can read its folders. Rewrite your problem sentence.
  3. Choose tools (20 min). Go through fits, fast enough and worth running with your numbers, and write down the hosted cost for comparison. Pick the model version and write the one-page data route.
  4. Build it: sign-off (30 min, plus waiting). Send the route to the DPO, IT and, where they're involved, the ethics committee or works council. Start nothing real until all have signed.
  5. Build it: machine and script (60 min). With IT: the job account, the folders, the network rule and the scheduled task. Write transcribe_local.py, point the settings at the real folders, and run the check on the test clips again.
  6. Understand it: prove the limits (30 min). In a runas window as the job account, try to read and write where it shouldn't and to reach a website. Measure the peak on your longest recording. Write the run sheet and let a colleague run the stop-and-delete procedure from it.
  7. Build it: first real recordings (20 min, plus review). Run one approved recording, have the named reviewer check it, and log the deletion.

Exit check

What you hand in: a signed data route and a working local transcription setup, with:

  • the one-page data route, signed by the DPO and IT, and by the ethics committee or works council where they're involved;
  • the check results on your test clips with the local model, and the measured peak memory and real-time factor on your own hardware;
  • a short test note showing the job account can read its incoming folder and write its drafts folder, and nothing else, and that the workstation can't reach the internet;
  • one real, approved recording with a reviewed transcript and a line in the deletion log;
  • a run sheet that a colleague has used to stop the job, redo a draft and restart it.

It passes when each of these exists and a colleague who wasn't involved can say, from the data route alone, where the audio is, who can read it and when it will be deleted.

Rule to remember

A recording stays in the building only when you can say where it is, who can read it, where it can't go and when it's deleted.

Details for experts

Checked on 23 September 2026. You don't need this to follow the book; it's for setting things up or answering a colleague.

WhatDetailsWhat it means for you
faster-whisperVersion 1.2.1, released 31 October 2025, MIT licence. On an NVIDIA card it needs CUDA 12 and cuDNN 9, NVIDIA's libraries that let programs use the card.Pin faster-whisper==1.2.1 in the project. If IT's drivers are older, ask them before you install.
Modellarge-v3 is published as Systran/faster-whisper-large-v3 on Hugging Face, MIT licence, revision edaa852ec7e145841d8ffdb056a99866b5f0a478. The main file is about 3.1 GB. turbo is a faster, slightly less accurate variant.Record the revision in the settings and the review list, so every transcript names the exact model.
Speed and memoryThe project's benchmark: 13 minutes of audio on an RTX 3070 Ti with 8 GB, large-v2 model. float16: 1 min 3 s, 4.5 GB. int8: 59 s, 2.9 GB. int8 stores the numbers in the model with less precision to save memory.An 8 GB card is enough for large-v3. Measure your own peak on your longest recording.
Without a graphics cardThe same benchmark on an 8-thread Intel i7-12700K, small model: 2 min 37 s, 2.3 GB of normal memory.Possible for a few recordings; too slow for a study.
HF_HUB_OFFLINE=1A setting read by the Hugging Face download library; with it set, nothing is fetched online.A second lock behind the network rule.
vad_filterUses the Silero voice activity model, bundled with faster-whisper, to skip silence longer than 2 seconds by default.Fewer invented sentences in pauses.
Hosted comparisonOpenAI's Whisper: $0.006 a minute. gpt-transcribe, OpenAI's newer transcription model without caption timings: $0.0045 a minute.120 hours of interviews would cost about $43 hosted.

Further reading and tools

Next books

Tools