The Seam Problem: Why Long Recordings Break Transcripts

Postat pe - Modificat ultima dată pe

An explainer on a real engineering problem, written from our own test notes.

A ninety-minute interview is an ordinary thing to want transcribed. For the software that does the transcribing, it is not ordinary at all. Most speech systems are built and tested on clips measured in seconds or a few minutes. Hand them an hour and a half of two people talking and something has to give: the recording gets cut into pieces, each piece is transcribed on its own, and the pieces are glued back together.

The gluing is where transcripts quietly go wrong. Not in the middle of a chunk, where the model is comfortable, but at the joins between chunks: the seams. This piece explains why seams fail, what the failures look like on the page, and the small set of checks that make them reliable again. The numbers come from a controlled test we ran: an 88-second synthetic dialogue between two clearly different voices, cut deliberately into 60-second chunks so that the seam would land in the middle of the conversation.

Why recordings get cut at all

There are three practical reasons to split long audio.

First, size. Many transcription interfaces accept a limited file size or duration per request. A ninety-minute file at normal quality is simply too big to send in one go.

Second, attention. Models that both transcribe and label speakers (“Speaker 1”, “Speaker 2”) tend to drift over very long inputs. They start strong, then begin merging speakers, skipping passages or summarising instead of transcribing. Shorter chunks keep them honest.

Third, recovery. If one request fails, you want to redo fifteen minutes, not ninety.

So cutting is not optional. The question is how to cut and rejoin without losing or duplicating anything.

Failure one: the cut is not where you think it is

The obvious way to split an audio file is to copy slices of it without re-encoding. It is fast and loses no quality. It is also imprecise: compressed audio is stored in small packets, and a copy-mode cut can only start on a packet boundary. The slice your code believes starts at 60.0 seconds may actually start somewhat earlier or later.

That sounds harmless until you combine it with timestamps. Every line the model returns is timed relative to the start of its chunk. To place it in the full recording, you add the chunk’s offset. If the real start of the chunk is not the offset you add, every line in that chunk is shifted. In our test, this shift was enough for the joining logic to discard a whole question-and-answer exchange near the seam, because it believed those lines belonged to the previous chunk’s territory.

The fix is unglamorous: re-encode each chunk when cutting (we use mono, 16 kHz, a modest bitrate, which is plenty for speech). The cut then lands exactly where the code says it does, and the offset arithmetic is correct by construction.

Failure two: the model’s clock is not your clock

Even with exact cuts, a model’s timestamps are estimates. Language models that “listen” to audio produce plausible times, not measured ones, and their errors grow across a chunk. Worse, a prompt can bias them. When we told the model that a chunk “starts N minutes into the recording”, some chunks came back with times relative to the whole file, others relative to the chunk. Two different clocks in one transcript.

Two changes resolved this.

  1. Never tell the model where the chunk sits. Every timestamp is requested relative to the start of the chunk, and the program adds the offset itself. One clock, owned by code.
  2. Re-time against a second, dedicated pass. A conventional speech-to-text model run over the whole recording gives segment-level timings that are measured rather than guessed. Each speaker turn from the labelling pass is matched to the segment whose words it best overlaps, within a window of about thirty seconds, and takes that segment’s start time.

The second pass also earns its keep elsewhere, as we will see.

Failure three: overlap creates duplicates, and naive deduplication deletes real speech

To avoid cutting a sentence in half, chunks overlap. We use 30 seconds of overlap on 15-minute chunks in normal use. The cost of overlap is that the same speech is transcribed twice, once at the end of chunk A and again at the start of chunk B, and must be counted once.

The tempting approach is to compare the start of chunk B with the end of chunk A and drop anything that looks similar. In our test this went wrong in both directions. The ending of the conversation appeared twice, because the duplicate lines differed slightly in wording and slipped under the similarity threshold. And elsewhere genuine lines were dropped, because they were compared against text from chunk A that was itself about to be cut away. Both copies of a passage were lost.

What works is to decide the seam first and deduplicate second:

  • Choose a cut point inside the overlap: the first turn in chunk B that starts at least ten seconds into the chunk (the opening seconds are the least reliable, since the model hears a sentence already in progress).
  • Keep everything from chunk A before that point, and everything from chunk B from that point on.
  • Only then remove any line from B that is a near-copy (70% word similarity or more) of the last few lines actually kept from A.

Deduplicating against what you keep, rather than against what you have, is the difference between a clean join and a hole.

Failure four: speakers swap names between chunks

Each chunk is labelled independently, so “Speaker 1” in chunk A is not guaranteed to be “Speaker 1” in chunk B. With two voices, the model will sometimes simply swap them.

The overlap solves this too. The same lines appear in both chunks, so you can see how labels correspond: if the line labelled “Speaker 1” in A is labelled “Speaker 2” in B, and the reverse holds for the other voice, chunk B’s labels are mapped back before joining. With two speakers the mapping is a vote across the overlapping lines; ties default to no change. Passing the last four lines of the previous chunk into the prompt, as context, further reduces how often a swap happens in the first place.

The check that catches everything else: coverage

All of the above prevents known failures. One more check catches unknown ones.

Because a dedicated speech-to-text pass runs over the whole recording, there is an independent count of how many words were spoken in each stretch of time. For every chunk, compare the words in the labelled transcript against the words in the same time window of the independent pass. If the labelled version contains less than 80% of them, something was skipped: the chunk is transcribed again once, and if it is still short, the gap is reported rather than shipped.

The same comparison produces a short list of passages worth a human look: places where more than a fifth of the transcript’s words cannot be found, in order, in the independent pass, plus anything the model marked as inaudible. In practice this list is short for clear recordings and long for poor ones, which is exactly what you want from a warning light.

What the test showed

On the 88-second, two-voice dialogue cut into 60-second chunks, the original pipeline produced a transcript whose first forty seconds were perfect, and which then lost a complete question-and-answer exchange at the seam and repeated its ending.

After the changes described here (exact cuts, one clock, re-timing against an independent pass, seam-first deduplication, speaker mapping in the overlap and coverage checks) two consecutive runs on the same audio produced all 12 of 12 speaker turns, each with the correct speaker, no duplicates and timestamps in order. The review list was empty on the second run.

A synthetic test is not a field trial. Real recordings bring cross-talk, quiet voices and room noise, and no amount of stitching restores words that were never clearly recorded. But the seam problem is different in kind from bad audio: it is a defect the software introduces on its own, on perfectly clear recordings. That makes it worth fixing first.

The short version

  • Cut long audio, but cut it exactly: re-encode the chunks.
  • Keep one clock. Ask for chunk-relative times and add offsets in code.
  • Re-time against an independent speech-to-text pass.
  • Pick the seam first, then deduplicate only against what you keep.
  • Use the overlap to map speaker labels between chunks.
  • Count words against the independent pass, and redo or flag any chunk that comes up short.

None of these steps is clever on its own. Together they turn a transcript that is right most of the way through into one that is right at the joins as well, which, for a ninety-minute interview, means right at the five places where the pieces meet.

Postat: 20 octombrie, 2026

Lxx777

B2B Lead Lists & Excel Data Cleanup

Verified B2B lead lists and clean, usable spreadsheets. Lead lists: tell me your industry, country/city and company size. I research each company individually from public sources (industry association directories, business registries, company websites), check the website is live and the business still trading, and record where every email or phone number came from. Each row is marked verified / i...

Următorul articol

Why Clear Technical Writing Is a Growth Advantage for SaaS Businesses