8Examples / blog

Local AI · Podcast processing · CQRS

How I Built DYORfunds: A Podcast Research Pipeline on an RTX 5070 Ti and a 4070 Laptop

I built DYORfunds.com to turn investing podcasts into something I can search and check: transcripts, timestamped takeaways, claims to investigate, and pages that collect mentions of an asset across shows. The audio runs through my development laptop’s RTX 4070. An external RTX 5070 Ti handles the language model work. A separate server keeps the website and the processing queues running.

By Sean Bennett · · 11 min read

The useful part is what happens after the first successful model call. New episodes keep arriving. Audio downloads fail. A laptop reboots. One processing stage gets faster and leaves another with a growing queue. DYORfunds has to keep making progress through all of that, while a visitor can still search the material already published.

This is the setup as of November 10, 2026. The screenshots are from that day; the performance figures below come from measurements on November 8 and 9. Continuous processing means the system keeps working through its catalog. Coverage depends on capacity and priorities.

DYORfunds homepage with search and links to investment podcast insights
The public site at dyorfunds.com. Readers can browse the output without knowing which machine produced it.

Three machines with different jobs

The public application runs in Docker on a separate server. It is a Next.js app with command and query APIs, a SQLite event store, and read models for the site. A feed crawler runs alongside it. Neither needs to hold a language model in memory to serve a published episode.

DYORfunds production hardware and responsibilities
MachineJob
Server11Docker, Next.js, RSS discovery, SQLite, website and APIs.
ASUS ROG Strix laptopUbuntu, RTX 4070 Laptop GPU with 8 GB VRAM, speech recognition and speaker separation.
Server19Windows, Node.js worker, external RTX 5070 Ti with 16 GB VRAM over OCuLink, Qwen through llama.cpp.

The laptop was already my development machine. Giving its GPU the speech work freed the 5070 Ti to concentrate on text. That hardware split only helped fully once the worker could use both machines independently.

One application, two GPUs

Server11 · public application

RSS crawler → commands → SQLite events → read models

Website, search index and work lists

↓ The Windows worker polls the work lists

Server19 · one worker, independent consumers

CALLS THE ASUS ROG LAPTOP

RTX 4070 · speech

Audio → Parakeet words and times → Sortformer speaker IDs

CALLS LOCAL LLAMA.CPP

RTX 5070 Ti · Qwen

Transcripts → summaries, claims, mentions and search answers

Speech and language processing overlap across machines. Background Qwen calls share one inference slot.

↓ Results return to the application as commands

New events update the public pages and the next work lists. The loop continues.
The backend owns durable state. Workers perform expensive work and report its outcome. GPU services stay on the local network; the worker reaches the application over HTTPS.

RSS feeds become durable work

The crawler starts with a curated catalog, synchronizes it at startup and daily, and refreshes feeds that are due. Automatic discovery can add more shows when there is room. A feed is identified from its normalized URL; an episode is identified from its show and feed GUID. Seeing the same episode again resolves to the same identity.

The backend records facts such as EpisodeDiscovered, EpisodeTranscribed and EpisodeAnalyzed. It folds those events into the current state of each episode. The worker asks the application for episodes needing transcription or analysis, does the work, and submits a result through a command API.

That is the CQRS split here: commands record changes; queries describe what a page or worker needs to see. The work lists come from the episode state. If a transcript has been saved but analysis has not finished, that episode remains eligible for analysis after a process restart.

Only the application writes the event store. It rebuilds its in-memory read models from events at startup, then updates them as new events arrive. Large transcript payloads are compressed on disk and fetched when needed, so listing hundreds of episodes does not require loading all their transcripts.

This follows the same broad approach I use in DealerProxy and ForkLocal: keep the durable business history in the application, and let background processors handle slow external work.

The 4070 turns audio into words, times and speakers

The Windows worker downloads an episode’s audio and sends it to an authenticated speech service on the laptop. The current production path combines NVIDIA’s Parakeet TDT 0.6B v3 with Sortformer v2.1. Parakeet supplies the words and native word timestamps. Sortformer supplies speaker activity, which the service joins to those words.

This changed during the build. The earlier diarized pipeline used Whisper large-v3, WhisperX alignment and Sortformer. On a 117-minute recording measured on November 8, that took 21 minutes 11 seconds. Parakeet plus Sortformer processed the same recording in 2 minutes 20 seconds, about 9.1 times faster on that episode. A subsequent live 65.5-minute episode completed the speech service in 98.5 seconds.

The comparison explains why I switched decoders. A successful timing run does not establish accuracy across the whole catalog. The reference clip and timestamp bounds were checked, and the output still needs scrutiny on unfamiliar names, overlapping voices and difficult recordings.

Eight gigabytes of laptop VRAM imposes a practical limit. The HTTP services stay running, but a shared lock admits one recording at a time. Recognition and diarization run in separate child processes, releasing their CUDA memory between stages. Model weights stay cached on disk. That trades some loading time for lower simultaneous memory use.

The services are enabled as user systemd units, with lingering configured so they start after a reboot without an interactive login. Readiness checks include model files, GPU access and a successful audio verification marker. If the laptop sleeps or becomes unreachable, speech work waits and backs off. Existing transcripts can still move through Qwen.

Speaker separation gives labels such as speaker_1. The worker asks Qwen to associate them with names only when the introduction supplies evidence. Uncertain names remain explicitly unidentified. This Sortformer version supports up to four speakers per recording, and assigning a voice ID does not verify a person’s identity.

The 5070 Ti makes the transcript useful

Server19 runs Qwen through llama.cpp. The model recorded in the latest measurements was Qwen3.6-35B-A3B in the UD-IQ3_S quantization. Production language processing uses this local endpoint; the optional hosted API path in the code is not configured in deployment.

A long transcript is split into timestamped chunks that fit the inference context. Qwen returns structured JSON for sections, assets discussed and checkable claims. A synthesis pass builds the headline, summary, topics and research checklist. Takeaways go through a separate evidence check against quoted transcript spans. The episode’s release date is included so verification notes have the right time context.

Asset mention extraction is another job. It connects spoken names to a dictionary of companies, funds, cryptocurrencies and other assets. The dictionary has imported seeds and curated aliases; unresolved cases can go to admin review. This is what lets an asset page on DYORfunds collect discussion across episodes.

One correction made a substantial difference to reliability: Qwen now selects transcript segment IDs, and application code supplies the timestamps and speakers from those segments. Earlier outputs could contain invalid timestamp ranges that rejected an entire batch. Now a bad candidate can be rejected individually while valid mentions are saved. A timestamp repair is accepted only when the quoted passage can be located unambiguously.

DYORfunds episode page showing the original audio player, summary and navigation to takeaways, claims and transcript
A published episode page brings together the original audio, structured interpretation and transcript. Its assertions remain podcast speakers’ claims for the reader to check.

Separate consumers keep the two GPUs working

The original serial loop could wait for laptop transcription before giving Qwen another job. Once speech moved to a separate GPU, that ordering left useful compute idle. Enabling PARALLEL_SPEECH=true gives the worker an independent speech consumer and an independent Qwen consumer.

Speech can transcribe one episode while Qwen analyzes an earlier one. Saving a transcript wakes the Qwen consumer. The text consumer alternates foreground mention extraction with episode analysis; older mention backfills use spare turns. Background Qwen calls, including speaker naming, share a FIFO mutex matching the model server’s single inference slot.

Each stage has its own failure backoff, increasing from 30 seconds to a maximum of 30 minutes. A broken speech endpoint does not put the analysis stage to sleep. Dead audio links are recorded and skipped without treating them as a model outage. The worker also prefetches audio to overlap downloading with other work.

Search has a different urgency. Full-text lookup uses a SQLite FTS5 read model. When a visitor requests an AI summary, the application queues it and the GPU worker checks for those requests every three seconds. Search summaries have bounded priority: they can interrupt background Qwen inference, whose calls can then retry. Limits on retries and waiting prevent searches from indefinitely starving episode processing.

These work-list queries are not job leases. The current design has one consumer per stage. Adding another worker for the same stage would need a claiming mechanism first, otherwise two workers could select the same episode.

Continuous processing needs a capacity policy

Discovering more feeds is easy compared with finishing their episodes. The implementation now has an explicit policy that estimates capacity from recent transcription, analysis and mention completions. It uses the slowest stage and reserves 15% for retries and searches. When there is too little recent evidence, it uses a starting estimate rather than presenting a short burst as proven throughput.

The queues prioritize recent episodes, core curated or manually added shows, fewer failed attempts, and shows served less recently. Other shows still receive reserved turns. Under overload that reservation is one turn in twenty. Automatic discovery and archive imports pause when capacity is tight; manual additions remain available.

This matters because a catalog containing thousands of shows does not imply that every newly released episode is already published. The November 10 directory update makes that distinction visible: readers can combine published or discovered episode availability with release-date filters.

DYORfunds podcast directory with episode availability and release-date filters and distinct discovered and published counts
The podcast directory defaults to shows with published summaries. Counts describe the selected filters; discovered episodes include work still waiting to finish.

A November 9 check of the preceding 24 hours recorded the following. These measurements describe different stages, so they should not be combined into a single end-to-end speed claim.

Measured DYORfunds processing results reported November 9, 2026
MeasurementObserved result
Unique transcripts successfully saved654
Audio represented by those transcripts372 hours
Average successful laptop speech processing40 seconds
Average transcription job, including download and postprocessing87 seconds
Episodes analyzed and published353
Sortformer attempts that ran out of VRAM22

Speech had become faster than downstream analysis: 308 transcribed episodes were awaiting analysis at that snapshot. The memory failures also show the limit of serializing models. It reduces simultaneous residency, but a single stage can still exceed available VRAM on some recordings. The next performance work has to address those failures and the text backlog.

Publication is another milestone to measure separately. An episode can have a public summary while its asset mention extraction is still pending. For fully processed throughput, I need transcription, analysis and mention completion together. GPU utilization alone cannot tell me that.

What keeps it running between deployments

A worker heartbeat runs on its own timer, so a long inference call still reports that the process is alive. Result submissions retry through temporary backend failures. During a deployment, a drain signal stops new work and lets active jobs finish their command submissions before the worker exits.

Diagnostics brings together service health, active jobs, queue counts, failures, token usage and separate time ledgers for speech and Qwen. Those ledgers include waiting and are distinct from measured GPU utilization. The distinction helped explain why a low-looking GPU percentage could coexist with a busy inference slot.

Tests exercise the worker against local HTTP fixtures: Qwen must publish while speech is pending, both active jobs must commit before a restart, and malformed mention output must not discard valid results. Real audio checks cover a different question: whether the deployed speech models produce useful words, timings and speaker labels on actual recordings.

A useful job for hardware I own

The 5070 Ti and laptop GPU give me a place to run repeated processing, experiment with models and improve old results. The application around them gives that compute a durable purpose: every successful transcript or analysis becomes something a reader can use later.

The most useful changes so far have been concrete: split speech from language inference, use a decoder with native timestamps, let the two machines work independently, derive citations from real segments, and make catalog growth respect measured capacity. Each change addresses a specific wait, failure or source of incorrect output.

Explore DYORfunds.

Browse investment podcast summaries, follow the timestamps back to the audio, and explore the assets being discussed across shows.

Visit dyorfunds.com →

Comments 0

No comments yet. Start the conversation.

Leave a comment

Site author? Sign in to reply officially.

Commenting is temporarily unavailable while CAPTCHA is being configured.