Back to Explore
GuideVibeFix editorialUpdated Nov 20, 2026

Speak It, It’s Written: Voice Input for Your Vibe Project

Hands covered in oil but need to note a recipe tweak? Voice input is built for exactly that moment. Using the fictional “Stove Notes” throughout: six build steps, a three-piece correction kit, a 12-item checklist, and five mistakes almost every team makes.

A woman wearing headphones speaks into her phone, dictating a note with voice input

First, be precise: which kind of voice input is this about?

“Voice input” means different things in different products. One kind is speech-to-text: you speak into your phone and the words land in a text field — typing with your mouth. Another kind is voice commands: you say “new note” or “open settings” and the product does it. A third kind is a voice assistant: a multi-turn conversation where you ask “what should I cook tonight?” and it suggests dishes and helps you order.

This guide covers only the first kind: speech-to-text input. The reason is practical: the other two are an order of magnitude more work — a solo team can spend six months and still not get them right — while the first kind can ship in a week and users feel it immediately. Get “spoken words become text” solid first; commands and assistants can come later. The whole guide follows one fictional example: a cooking-notes app called “Stove Notes,” where a user named Amei, hands covered in oil in the kitchen, wants to jot down a tweak to a recipe. The product, numbers, and dialogue in the example are all fictional, invented to make the reasoning concrete — not real operating data from a real product. As you read, swap “Stove Notes” for your own product: the logic is the same.

When is voice input worth building? Do three sums first

The first sum is “how busy are the user’s hands?” Cooking with oil on your hands, driving with both hands on the wheel, holding a child, doing fieldwork with tools in hand — when your hands are full, voice input is not a nice-to-have, it is the only input method that works. Amei’s typical scene in Stove Notes is exactly this: left hand holding a pot, right hand holding a spatula, wanting to note “half a spoon less salt” — typing is impossible, saying one sentence works. If your users mostly sit with both hands free, voice input can wait further down the list.

The second sum is “how long is the input?” A three-word search box or a phone number does not need voice. A hundred-word recipe step, a meeting note, a fifty-word piece of feedback takes two minutes to type and twenty seconds to say. A useful rule of thumb: once a single input passes twenty characters, voice starts to pay off; past fifty, the advantage is obvious. Go look at the longest input fields in your product and see how much users actually write in them, then decide.

The third sum is “who are your users?” Older users who type slowly, users with poor eyesight or limited hand mobility, and users who speak fluently but whose Mandarin is non-standard get far more from voice input than the average user. For them, voice input is not an efficiency tool — it is the line between being able to use your product and not being able to. If two of the three sums point to yes, build it; if all three do, build it now; if none do, do something else first.

Six steps: from tapping the microphone to text landing in the field

Step one, pick a technical route. A solo team has three options. The browser’s built-in Web Speech API: free, works out of the box, no server to run — but recognition needs the network, Chinese recognition is only “decent,” and audio leaves the browser; good for a first probe. Server-side recognition, such as Whisper-class models: the most accurate, handles dialects, can be self-hosted — but costs money or a server of your own; right when accuracy matters. On-device models, such as a lightweight recognizer running on the phone: works offline, best for privacy — but drains battery, takes up space, and struggles on old phones. My advice: start with the Web Speech API, get the whole pipeline working, and keep the interface clean so swapping in server-side recognition later means changing one layer, not rewriting the UI.

Step two, where the button goes. Put the microphone button to the right of the input field, where the thumb can reach it. Don’t hide it in a submenu, and don’t make it a hidden gesture that only works with a long press. When the keyboard pops up, the button must not be covered by it; when the field shrinks, the button must not vanish with it. A user holding a phone one-handed in the kitchen cannot hit a tiny target: make the minimum tap area 44 by 44 pixels — that is the floor, not the goal.

Step three, recording states must be readable at a glance. Three states, each with its own color, text, and waveform — all three, no exceptions. Idle: a gray microphone, waiting for a tap. Listening: a red microphone with a bouncing waveform and the words “Listening — tap Done when you finish.” Processing: a spinner with “Turning speech into text.” The worst failure is a user talking for half a minute while the screen shows nothing — she has no idea whether the product is listening, stuck, or never heard her at all.

Step four, stream the text onto the screen; don’t hold it back for a big reveal. As the user speaks, words appear; interim results in gray, confirmed results in black. Never wait until the user finishes and taps stop before dumping the whole paragraph at once — those few seconds of waiting are exactly when people conclude “it’s broken” and leave. Streaming has a second benefit: the user spots a mistake immediately and fixes it on the spot, instead of reworking the whole passage afterward.

Step five, punctuation and paragraphing. Raw recognition output is one big lump of unpunctuated words, exhausting to read. Do at least two things: add periods and commas automatically, and start a new line or paragraph after a pause longer than about 1.5 seconds. One step further: turn spoken numbers into digits automatically — “one hundred twenty grams” becomes “120 g”; handle time words like “half past three” in context. How well punctuation works is the dividing line between users thinking “this is usable” and “this is a toy.”

Step six, how the text lands in the field. Append the transcript at the cursor position. Never overwrite what the user already typed. If the user typed “peel the potatoes” and then dictates “dice and blanch for one minute,” the result must be “peel the potatoes, dice and blanch for one minute” — not the second sentence replacing the first. Right after it lands, offer an “Undo this dictation” action that restores the field to its pre-voice state. Users only dare to speak freely when a mistake can be undone in one tap.

What about misrecognition? Correction is the lifeline of voice input

First, accept reality: speech recognition will never be one hundred percent accurate. Chinese homophones are the worst — “add another spoon of salt” and its sound-alike twin are constantly confused by machines; proper nouns are just as bad — dish names, people’s names, place names the model has never seen get guessed wildly; numbers go wrong too — “one hundred twenty” could be 120 or 102. Hoping for zero errors is unrealistic; the real craft is what happens after an error.

Correction needs three tools, and missing any one of them is a failure. First, tap-to-fix: tap a wrong word, get a few candidates, tap one to replace it — don’t make the user delete and retype. Second, re-speak a selection: highlight a passage, tap the microphone, re-say just that part, and only the selection is replaced. Third, plain keyboard editing: the transcript is ordinary text, editable exactly like anything the user typed. Many teams ship only the third and think “they can edit it anyway” — but making users fix things character by character is no different, experientially, from making them retype the whole thing.

One step further is a custom vocabulary. Feed the recognizer your product’s high-frequency proper nouns in advance: dish names, people’s names, place names, brand names. In Amei’s Stove Notes, words like “blanch,” “thicken with starch,” and “dark soy sauce” were wrong nine times out of ten at first; once they entered the vocabulary, they came out right so often users thought the product had gotten smarter. An even cheaper trick: whenever a user corrects a word, remember it and prefer the user’s version next time — learning from the user beats guessing the vocabulary yourself.

Mark low-confidence words; don’t pretend to be sure. The recognizer knows how confident it is about each word — put a dotted underline under the ones it is unsure about, telling the user “this might be wrong, check it.” That way users only check a handful of underlined words instead of proofreading the whole passage. A product that acts certain when it is not will be abandoned after a single bad experience.

Finally, be honest about the environment. A quiet kitchen and a noisy wet market can halve recognition accuracy. The product should dare to tell the user the truth: when ambient noise is high, show a gentle note — “It’s noisy here, recognition may be less accurate” — which beats letting the user rage at a screen full of wrong words. You can even suggest trying again somewhere quieter, instead of pretending everything is fine.

The funnel: where exactly does voice input lose people?

In Stove Notes’ first month after launch, the voice input funnel looked like this: 1,000 people opened a new note, 820 saw the microphone button, 610 tapped the microphone, 534 got a usable transcript, and 402 used voice again next time. Step-to-step conversion was 82.0%, 74.4%, 87.5%, and 75.3%; overall, from opening a note to forming the habit, 40.2%.

Voice input funnel: 1,000 people opened a new note, 820 saw the microphone button, 610 tapped the microphone, 534 got a usable transcript, 402 used voice again next time

The number most worth staring at is not the final 40.2% but the first-to-second step: 820 people saw the button and only 610 tapped it — a quarter lost. The problem is not technical, it is trust: users worry about being overheard, about getting a pile of wrong words they must fix, about not knowing what to say into a phone. And the fix is not technical either: put one example sentence next to the button — “Try saying: half a spoon less salt” — and users dare to speak.

The second step worth watching is the last one: 534 people got a usable transcript, but only 402 came back. The first experience decides everything: if the first transcript is badly wrong and fixing it is painful, users conclude “this doesn’t work” — and rarely return. So in the first month after launch, don’t watch total usage; watch first-use satisfaction: after the first transcript, did the user edit it, delete it, come back the next day?

Experience details: button, waveform, permissions, silence — none optional

Ask for microphone permission only the first time the user taps the microphone — never when the page first loads. A user who just opened your product has no idea what the microphone is for; a permission prompt at that moment gets refused by nine out of ten. The right order: the user taps the microphone, then the system asks. If the user refuses, don’t just write “Please enable the permission” — write exactly where to go: on Android, “Settings — Apps — Permissions — Microphone”; on iOS, “Settings — Your App — Microphone,” step by step, plus a button that jumps straight to settings.

Cap a single recording at 60 seconds — a reasonable number. Past 60 seconds, stop automatically and say “60 seconds recorded — here is the transcript; say another passage to continue.” Unlimited recording has two costs: users ramble, come back to three paragraphs of errors, and can’t face fixing them; and the longer the audio, the more the second half drifts off. Record and transcribe in segments — better for the user and for the model.

Write privacy in plain sight. Recording starts only after the user taps the button, and stops when they tap stop or release — there is no background recording. Tell users where the audio goes: with built-in browser recognition it never leaves the device; with server-side recognition, say which server it goes to, whether it is stored, and for how long. By default, don’t store audio at all — store only the text. If the business needs audio stored, get explicit consent, and let users delete it at any time.

Give feedback at the start and the end. A light vibration when recording starts; a short sound when it stops. A user in the kitchen isn’t looking at the screen — vibration and sound are how she knows “recording started” and “recording finished.” A product with no feedback makes users tap the button over and over, starting and stopping, ending up with fragments.

Don’t assume everyone speaks standard Mandarin. Let users pick a language or dialect — at minimum, offer Mandarin, Cantonese, and English, the three most common choices. And when a dialect is picked, the recognition model must switch with it — never the joke of a UI that says “Cantonese” while the recognizer still runs a Mandarin model. Dialect users feel the care most, and they are the most likely to spread the word for you.

The pre-launch checklist: 12 items, none optional

1. The microphone button sits to the right of the input field, with a tap area of at least 44 by 44 pixels, and is not covered when the keyboard pops up.

2. The three recording states — idle, listening, processing — each have their own color, text, and waveform, so users never have to guess.

3. Text streams onto the screen while the user speaks — interim results gray, final results black — never held back until the end.

4. Pauses over 1.5 seconds start a new line or paragraph, periods and commas are added automatically, and spoken numbers become digits.

5. Transcripts are appended at the cursor, never overwrite existing text, and come with an “Undo this dictation” action.

6. Tap-to-fix, re-speak a selection, and plain keyboard editing all work.

7. The product’s high-frequency proper nouns are in a custom vocabulary, and words the user has corrected are preferred next time.

8. Low-confidence words carry a dotted underline, so users only check the flagged words.

9. Permission is requested only on the first microphone tap; a refusal leads to step-by-step recovery instructions and a direct link to settings.

10. A single recording caps at 60 seconds, stops automatically with a notice, vibrates lightly at the start, and plays a short sound at the end.

11. The privacy note states where audio goes; by default no audio is stored, and storing it requires consent and must be deletable.

12. Tested at least once in each of three real noisy environments — a wet market, a bus, a subway — with a gentle warning when it is too noisy.

Common mistakes: almost every team makes at least one of these five

The first mistake: testing only in a quiet office. In the office, recognition hits 98%; in the market and on the bus it drops to 70%, and the screen fills with wrong words. Voice input must be tested in real places — go to a wet market, ride the subway, record a few genuinely noisy clips, and keep them as regression test cases.

The second mistake: letting the transcript overwrite what the user already typed. The user types half a sentence, dictates the rest, and the first half vanishes. This is the most destructive bug of all: users who lose text don’t complain — they uninstall. Before launch, type a passage in your own product, then dictate a continuation, and verify by hand.

The third mistake: no way to fix errors except re-speaking the whole passage. Say it again, and the same words come out wrong again; after three attempts the user gives up. Correction is not a garnish — it is the line between voice input working and not working. A product without tap-to-fix should not ship voice at all.

The fourth mistake: asking for microphone permission the moment the page loads. The user hasn’t figured out what the microphone does yet, gets startled, taps refuse — and every later tap fails silently, earning the product a reputation for “voice being broken.” Permission must wait until the user deliberately taps the microphone.

The fifth mistake: building voice input into a voice assistant. The user says “half a spoon less salt” and the product replies “OK, noted — anything else I can help with?” — pure noise. The job of voice input is to turn speech into text; once the words are there, shut up. If you want an assistant, start a separate project.

Drawing the line: voice input is not a voice assistant, and not a voice message

Voice input and voice assistants share technology, but their product goals are completely different: the former is an input method whose output is text; the latter is a conversation whose output is actions and answers. When someone on the team suggests “let’s just add the assistant too,” push back: an assistant needs multi-turn dialogue, intent understanding, and action execution — a different project. Doing both at once means doing neither well.

Voice input is not a voice message either. A voice message is a recording sent to someone else to listen to; voice input turns your own words into your own text for reading. Storage, privacy, players — the things voice messages need to worry about — voice input simply doesn’t need. Don’t copy them over.

One line on how this relates to guides already published: the keyboard-shortcuts guide is about a keyboard-first workflow; voice input is another input method — complementary, not overlapping. The accessibility guide is about making your product usable for people with disabilities, and voice input is an important part of that — but this guide covers the full journey from choosing a route to launch. The rich-text-editor guide is about the editor itself; how dictated text lands in rich text, with paragraphing and formatting, is stated as a principle here — the details live there.

After voice input: don’t let the transcript lie there

Transcribed text must be searchable. A user dictates “less sugar in the tomato beef stew” last month and wants it back this month — searching “beef stew” has to find it. Dictated text and typed text must be equals in the search index; never the oddity where “typed notes are searchable, dictated notes aren’t.”

Review the funnel once a week, watching just two numbers: the share of microphone taps that yield a usable transcript, and the share of first-time users who come back the next day. If the first drops, recognition or correction has a problem; if the second drops, the first experience has a problem. Don’t stare at total usage — that number is easy to inflate. Retention is the truth.

Finally, the question of audio retention. By default, don’t store audio — store only text. That is the simplest and safest choice. If you later want to use users’ voice data to improve recognition, ask for consent again, and let users delete all of their audio at any time. Voice data is biometric: once leaked, it can’t be “changed” the way a password can. That red line should be drawn on day one.

Views 7Comments 0

Comments (0)

ME
0/1000
Loading comments...
Browse projectsPublish your project

Related articles

Real photo: a laptop, tablet, and phone on a wooden table showing the same green-leaf website, the phone view with navigation in one column, a potted plant nearby
Guide
Squashed on phones? Responsive layout and media queries, explained plainly

One page should stand up on a phone, a tablet, and a computer. This guide follows MDN's Responsive web design, Using media queries, and the viewport meta reference: fluid HTML, the viewport tag, fluid grids and max-width, images that never burst their container, media query syntax, breakpoints set by content, mobile first, responsive type, testing capability instead of width, and a pre-launch checklist.

Mobile AppsDesign ExperienceFrontend Engineering
Real photo: hands typing on a MacBook Pro showing JavaScript code that changes HTML content, with a white mouse, papers, and binders on a white desk
Guide
Functions without the confusion: JavaScript functions, parameters, and arrow functions, explained plainly

You already call functions every day; this guide names what you have been doing. Following MDN's Functions, Arrow function expressions, and Rest parameters: declarations versus expressions, parameters and arguments, default values, rest parameters, spread syntax, return values, arrow function shorthand, the this trap, callbacks, and scope.

Tool TipsFrontend EngineeringAI Coding
Real photo: a Casio scientific calculator on a wooden desk showing 123456789 + 987654321 = 1111111110, beside handwritten math notebooks, a pen, a mug, and a laptop edge
Guide
Don't let 0.1 + 0.2 break your bill: JavaScript numbers and Math, explained plainly

Numbers in JavaScript are one type, Number, stored as 64-bit floats — which is why 0.1 + 0.2 is 0.30000000000000004. This guide follows MDN's Basic math in JavaScript, Math, and Number: one number type, float error, counting money in cents, converting strings, NaN and Infinity, safe integers, the four rounding methods, Math.random, the Math toolbox, and formatting for display.

Tool TipsFrontend EngineeringAI Coding