Recording an idea is easy. Finding it again is the part worth building for. A folder of voice notes can contain something useful and still be a terrible place to look when you sit down to write.

This project turns a recording into a searchable text note while keeping a route back to the audio. You can begin with a recorder you already use, a transcription step and one destination folder. The example below handles the final save without overwriting an earlier note. It is a starting point you can adapt, not a claim that every recorder or transcription service behaves identically.

Choose where the finished note will live

Pick the place you would actually check when working on an idea. That could be a folder of Markdown files, a notebook app or a document inbox. A new dashboard is rarely necessary for the first version. If the result lands somewhere you never visit, the automation has moved the thing you forget rather than making it easier to find.

A useful note needs the transcript and a reference to the original recording. Add a captured time if your recorder supplies one reliably. Keep the title simple until you have reviewed the text. An automatically confident title can make a mistranscribed idea look more settled than it is.

Decide how you will recognise an item later. Give each recording a stable ID when it first enters the process and carry that ID through retries. The ID belongs to the recording, not to a particular transcription attempt. A second transcription of the same audio should not quietly look like a completely new idea.

For the first run, record a short thought you can listen back to easily. Say a project name, a useful detail and a question you want to return to. You will have something concrete to compare with the text, without spending the whole test reviewing a long recording.

Transcribe a recording you can check

You can choose a local transcription model or a service that accepts audio. Check the supported file type and size before joining up the workflow. If you use a hosted service, understand where the recording is going and what that provider retains. A local tool also needs storage and processing capacity, so try it on the machine you intend to use.

OpenAI's open-source Whisper project is one local option. Its documentation covers installation, model choices and command-line transcription. It depends on additional software, including FFmpeg; the note-saving code further down does not install or run a speech model. Keep those two steps separate while getting the workflow working.

Do not judge the result only by whether it produced a fluent paragraph. Listen for names, negations and numbers. 'Do not publish that' becoming 'publish that' is a much more serious change than missing a comma. Background noise or a quiet recording can also produce misleading output, so a transcript needs a quick human check before it drives another action.

Keep the recording until you have checked the note and decided what retention makes sense. For personal voice notes, recording your own speech is a straightforward starting point. Do not extend the same setup to recording other people without first agreeing what is being recorded and how it will be used.

Sources: Whisper: official repository and README.

Keep the hand-off small and inspectable

Have the transcription step produce an object with recording_id and text. The ID is your existing capture reference, and text is the returned transcript. If the service uses different field names, map them at this boundary rather than making every later step understand that provider's response format.

For a manual test, create transcript.json in a fresh working folder. Give it a string recording_id such as note-001 and a text field containing a couple of sentences. This lets you check the save logic without uploading a recording or waiting for a model. Once it works, substitute the real transcript output.

Reject missing text instead of saving an apparently successful empty note. Also distinguish a service error from silence in the source recording. Those need different fixes: one might need an account or connection check, while the other needs a usable recording. Preserve enough status to know which step stopped.

n8n can connect the steps if you want a visual workflow, but it is not required for this example. A manual export and a small Python script are enough to prove the destination works. Add unattended capture only after you know what a correct note looks like.

Sources: n8n: error handling.

Save the note without replacing an older one

Save this as save_note.py beside transcript.json and run it with Python 3. It uses only the Python standard library. The result is a Markdown file inside notes. The hash in its filename comes from the recording ID, giving that recording a stable destination without using user-supplied text as a filesystem path.

The script opens the destination in exclusive creation mode. If that path already exists, it compares the content. An identical repeat reports that the note is already saved; different text for the same recording stops for review. It does not choose which version is correct or overwrite your previous note.

This is a small local example, not a multi-user document system. Keep it in a folder you control. If you later run several workers or save to an external service, use that destination's own duplicate protection and record the returned document ID. A neat local filename alone cannot prevent duplicate records elsewhere.

import hashlib
import json
from pathlib import Path

item = json.loads(Path("transcript.json").read_text(encoding="utf-8"))
recording_id = item.get("recording_id")
text = item.get("text")
if not isinstance(recording_id, str) or not recording_id.strip():
    raise ValueError("Keep the original recording ID")
if not isinstance(text, str) or not text.strip():
    raise ValueError("No transcript to save; check the audio")

key = hashlib.sha256(recording_id.encode("utf-8")).hexdigest()
folder = Path("notes")
folder.mkdir(exist_ok=True)
target = folder / (key + ".md")
note = "# Voice note: review needed\n\n" + text.strip() + "\n"
try:
    with target.open("x", encoding="utf-8") as output:
        output.write(note)
    print("Saved:", target)
except FileExistsError:
    if target.read_text(encoding="utf-8") != note:
        raise ValueError("This recording already has a different note; review it")
    print("Already saved:", target)

Sources: Python: hashlib, Python: built-in open.

Make a useful note before making a clever summary

Read the saved Markdown file and correct the transcript while the audio is still easy to find. You can add a working title, tags or a short summary after that. Keep your additions distinguishable from the transcript so that a suggested task does not become something you supposedly said.

For example, a voice note about trying a motion sensor might contain a question about where to put it. Your next action could be to test two positions. A summary should not turn that into a claim that the sensor has already been installed. This is where tidy writing can accidentally erase the uncertainty that made the note useful.

If you add an AI summary step, keep the original text alongside it and review names and factual details. There is no need to add automatic posting, calendar invitations or messages to other people. A clean note in the right folder is already a complete output for this project.

Try a repeat, a blank and a correction

Run the same sample twice. You should get one file and an already-saved message on the second run. Next, empty the text field and confirm that the script stops without creating another note. Then change the text while keeping recording_id unchanged: it should ask for review rather than replacing the first version.

Try a different recording ID containing spaces or punctuation. The generated filename should remain a hash inside notes. Keep a separate mapping to the source recording in a fuller workflow, because the hash is not a useful human title or a way to locate audio by itself.

Once those cases behave as expected, connect one real recording. Check the whole journey from capture to transcript to saved note, including what happens if the transcription service fails. Bring that journey to a Show & Tell. The interesting result is being able to find an idea when you need it, not the number of services in the middle.

Sources and further reading

Continue with