This guide covers the whole rig for one person with no crew: what the glass does to your light, how to mount a phone or small camera, the mirroring trap, lighting your face when the prompter itself is a light source, and the software half that most hardware guides skip.

What a beam-splitter actually does

The glass in a prompter hood is coated so that it reflects some light and transmits the rest. Your screen lies flat below the hood, facing up; its image bounces off the glass towards you; the camera behind the glass sees through it to your face.

The part nobody mentions in the product photos: that split is expensive. Depending on the coating, the glass passes roughly a third to a half of the light in each direction. Your camera loses up to a stop through the glass, and — more importantly for reading — the script you see is dimmer and lower-contrast than the same screen viewed directly.

Two consequences follow from that maths, and they shape everything else in this guide. First, whatever looks comfortably readable on the bare screen will be harder to read through glass, so set text and contrast for the rig, not the desk. Second, subtle visual cues die in the mirror. Anything your prompter software signals with a gentle tonal shift — a faint highlight, a slightly dimmed line — needs to be bold enough to survive losing half its light.

Choosing glass and a mount

You do not need broadcast kit. For a solo setup there are three sensible rungs:

A smartphone prompter hood (roughly £30–£100) clamps your phone below a small glass panel, with the camera — often a second phone — mounted behind. Fine for arm's-length to about two metres. Check the stated glass size against your phone: a 6.7-inch phone in landscape wants the larger hoods.

A tablet-and-camera rig (£100–£250) takes an iPad or large phone as the screen and a mirrorless or compact camera behind. The bigger screen is the point — at two to three metres, screen area buys you font size, and font size buys you a natural eye line.

Purpose-built units with an integrated screen sit above that. Worth it if you shoot daily; overkill for a first rig.

Whichever rung: look for 70/30 glass (70% transmission) described as "beam splitter" rather than ordinary mirror glass, a hood that actually blocks room light from hitting the back of the glass, and a mount that lets you set the whole assembly at your seated or standing eye level. The most common first-rig mistake is a prompter at chest height — you end up looking down on camera, which reads as reading.

If you're weighing this rig against simply propping a phone next to the lens, the trade is eye line: with the script beside the lens, the further back the camera, the less visible your glances. The beam-splitter removes the glance entirely, which is why it wins for anything closer than about three metres. We've written more about eye line and distance in how to read a teleprompter without sounding wooden.

Mirroring: the whole surface flips

The glass reverses everything horizontally. Your prompter software must have a proper mirror mode that flips the display so the reflection reads correctly — reading mirrored text is possible for about a sentence and miserable thereafter.

The subtler point is that everything on the screen flips, not just the words. A control in the bottom-right of the screen appears bottom-left in the glass. A progress bar that fills left-to-right appears to fill right-to-left. So when you're evaluating prompter software for a rig, look at what happens to the interface in mirror mode, not just the script: anything that depends on left meaning left will lie to you mid-take. Good rig-aware software treats mirroring as a first-class mode; TellyPrompter, for instance, is designed so that no cue depends on left/right meaning, precisely because mirrored rigs are normal use rather than an edge case.

While you're in the settings: if your phone is locked to portrait, look for a rotation control in the software itself, since some rigs want the screen turned 90 degrees.

Lighting yourself when the screen is pointed at your face

A prompter is a light source aimed directly at the presenter. In a dim room it becomes your key light — an unflattering, screen-coloured one that also reflects in glasses.

The fix is not a darker screen; you need that brightness to survive the glass. The fix is more light elsewhere, so the prompter stops being the brightest thing in your face:

• Key light first. One soft light at roughly 45 degrees, brighter than the prompter's glow on your face, and the screen's contribution disappears into it.
• Dark interface, light text. A mostly-dark prompter screen throws far less light and reflects far less in glasses and in the glass itself. Near-black backgrounds are standard in prompter software for exactly this reason.
• Glasses wearers: raise the key light and tilt it down, and angle the prompter hood a degree or two off square if you can. Most lens reflections are the screen; a dark background removes most of the problem at source.
• Check the hood for leaks. Room light striking the back of the glass washes out the script. If your text looks milky, shade the back of the hood before touching any brightness setting.

The software half: scroll speed should be the read

Here is where most rig guides stop, and it's half the rig.

A conventional prompter app asks you for a scroll speed — a words-per-minute number — before you've said a word, and then plays the script at that speed while you perform to it. On a beam-splitter this is worse than it is on a propped phone, because the whole point of the glass is unbroken eye contact: there's nowhere to glance for a controls check, and your hands are usually in frame. If the scroll runs ahead of you, the recovery options are to chase it or to stop the take.

The alternative is software that listens. TellyPrompter follows your voice: as you read, a highlight tracks the word you're actually saying, through pauses, ad-libs, skipped lines and backtracking, so the pace of the scroll is set by the read rather than by a guess you made before it. On a rig this matters twice over — you can't reach the phone to correct a bad speed guess, and you can't afford the eye movement of hunting for your line. Speech recognition runs on the device and the audio is never uploaded.

It runs in the browser, works with mirror mode and rotation, and the text and contrast settings are built for reading at one to three metres through glass. One honest limit: voice-following depends on the browser's speech recognition, so quality varies by platform and language, and Firefox doesn't implement the API at all — there, the constant and sound-level modes still work.

The two-minute setup checklist

Run this from your performing position, not from beside the rig:

1. Height — glass at eye level, lens behind it at eye level. You should be looking dead ahead.
2. Mirror mode on, and confirm the script reads correctly in the glass.
3. Font size — step back to your mark. Read a line. If you lean or squint, go bigger. Bigger than feels necessary is usually right.
4. Contrast — light text on a near-black background; check nothing important is carried by a subtle tonal difference, because the glass just ate half of it.
5. Key light on, brighter on your face than the screen's glow. Check glasses for reflections.
6. Hood check — no room light washing the back of the glass.
7. One read aloud — half the script, at performance volume, watching the highlight or the scroll. If it keeps your place, sit down and take the take.

The rig's job is to disappear. When the glass is clean, the text is big, the mirror is set and the scroll is following you rather than the other way round, what's left is you, talking to the lens — which is the whole point of bolting a mirror to a camera in the first place.

This piece is about that choice: the three ways prompter software can scroll, what each one asks of you mid-take, and how to think about browser-based prompters, offline shooting and the cases where a paid desktop suite genuinely is the better answer.

The hardware in one paragraph

The Elgato Prompter packages the classic beam-splitter design — angled half-mirrored glass with the camera shooting through it — around its own small screen, and connects to your computer over USB, where it shows up as an extra display. Elgato ships companion software that can put a script, your camera feed or other content on that screen. What the hardware decides: your eye line (excellent, since the script sits directly over the lens), your mounting options, and the physical size of the reading surface. What it does not decide: how the text moves. Anything you can show on a display, you can prompt from — including a browser tab — so the scrolling behaviour is entirely a software question.

That's worth dwelling on, because most reviews of the device spend their word count on build quality and lens compatibility and a paragraph on software. Yet the software is the half you'll be negotiating with mid-take.

The three ways prompter software can scroll

Every prompter app, whatever its badge, moves text in one of three ways.

Constant scroll. You set a speed — words per minute, or a slider — and the text moves at that speed from the moment you start. This is the traditional mode, and the one most prompter software defaults to.

Sound-level scroll. The halfway house: the text advances while the microphone hears you speaking and pauses when you stop. It knows that you're talking, but not what you're saying.

Voice-following. The software listens to the words themselves, matches them against the script, and keeps a highlight on the word you're actually saying. The scroll has no speed of its own; it has your speed.

Why constant scroll means performing to a metronome

Constant scroll asks you to answer an impossible question before the take starts: how fast will I speak? Not on average — at every moment. You'll naturally speed through the setup of a point and slow into the point itself; a fixed scroll averages both into one tempo, and the read flattens to match.

Then there's the error case. Pause longer than the scroll budgeted, and the text drifts ahead; ad-lib a sentence, and it's gone by the time you come back; stumble, and the script continues without you. On a beam-splitter this is particularly unforgiving, because the entire benefit of the device is unbroken eye contact — there's no natural moment to glance at a control, and the recovery from a runaway scroll is either chasing it or stopping the take.

None of which makes constant scroll useless — more on that at the end — but it explains the wooden quality of many prompted reads: the speaker's attention is split between saying the words and tracking a conveyor belt.

What voice-following looks like on this device

TellyPrompter runs in a browser, so putting it on an Elgato Prompter is just dragging a tab onto that display and going fullscreen. From there the experience changes shape: you read, and the highlight follows the word you're saying. Pause to think, and it waits. Skip a paragraph you've decided against, and it picks you up where you actually resumed. Go back to retake a sentence, and it goes back with you.

The practical difference on this hardware: your delivery stops serving a number. The Elgato's screen is close to your face by design, so a scroll mismatch is very visible; a highlight that's simply always on your word removes the mismatch as a category. Voice commands cover the moments your hands are on a keyboard out of frame or not available at all — saying "Telly, stop" ends a take, "Telly, again" retakes it.

Speech recognition runs on the device and the audio is never uploaded.

Two honest limits, because they're the browser's rather than anyone's marketing. Voice-following depends on the Web Speech API, which Firefox doesn't implement — in Firefox everything else works, and the constant and sound-level modes still scroll, but the listening mode isn't available. And recognition quality belongs to the browser, not the prompter: it varies by platform, language and microphone, and no prompter software can tune it. If a specific language matters to you, the two-minute test below settles it faster than any spec sheet.

Browser-based vs installed, and shoot day without wifi

A reasonable instinct says an installed desktop app must be more dependable than a website. For prompting on this device, the distinction is thinner than it looks.

A browser prompter needs no install, no account and no updates to manage, and it works identically on the laptop in your studio and the borrowed machine at a client's office. The traditional weakness — needing a connection — is solved by the installable web app pattern: TellyPrompter installs as a PWA, and after the first online visit the prompter itself works offline. A shoot location with unreliable wifi is a normal place to open a teleprompter, and the software is built on that assumption.

The genuinely browser-shaped limitation is the one above: the recognition engine is whichever one your browser provides. An installed suite can ship its own.

Honest fit: when a paid desktop suite is the better answer

If your work looks like broadcast — a second operator, hardware scroll controllers, timecode, multi-prompter output to several screens at once — the professional desktop suites are built for exactly that, and a browser tab is not trying to be. Similarly, if you must prompt in Firefox specifically, or you need guaranteed recognition in a language your browser handles poorly, an app that bundles its own recognition may serve you better.

But if you're the person the Elgato Prompter is mostly sold to — one creator, one camera, recording yourself to a lens — the questions that decide your software are simpler. Does the text move at your pace or its own? Does it survive a pause, an ad-lib, a stumble? Does it work in the room with bad wifi?

The test costs two minutes: put a tab on the prompter's screen, paste a real script, and read it once aloud — including one deliberate pause and one deliberate ad-lib. Whichever software keeps your place through both has answered the question. The hardware you've already chosen well; this is the other half. And once the software is settled, most of what remains is delivery — which we've covered in how to read a teleprompter without sounding wooden.

This guide walks the ladder from free to serious, then covers the physics of reading at distance, the mirror and rotation settings rigs demand, how to run a take when you can't touch the phone, and whether to record on the same device or a second one.

The three phone setups

Propped next to the lens. The phone leans against something beside your camera — or beside your laptop's webcam — showing the script. Cost: nothing. The compromise is eye line: your eyes are on the script, not the lens, and the closer the camera, the more visible the difference. Workable when the camera is far enough back that the angle between script and lens gets small; at arm's length, the audience can watch you read.

A clip-on mirror rig (roughly £20–£60). A small hood and mirror assembly that clips over your phone or sits on a tripod, reflecting a second device's screen — or splitting one phone between script and camera. The step up is real: the script moves close to or over the lens. The compromises are size (a small mirror means less text on screen at once) and the mirror flip, which your software has to handle.

A full beam-splitter (£30–£100 for phone-sized hoods). Half-mirrored glass at 45 degrees, script reflected directly over the lens, camera shooting through. Eye contact and reading become the same act. This is the setup that makes "reading" invisible, and we've covered the full build in our beam-splitter setup guide. Worth knowing before you buy: the glass passes roughly a third to a half of the light, so everything about text and contrast has to be set more boldly than the bare screen suggests.

The honest ladder advice: start propped, with the camera further back than feels natural. If you find yourself shooting weekly, the £30 hood pays for itself in the first session where nobody can see your eyes flick.

Reading distance: why desk settings fail at two metres

Here's the mistake nearly everyone makes once: you set up the script sitting at the phone, where the default font looks generous, then you step back to your mark and discover you're squinting at a wall of ants.

A phone teleprompter is read at one to three metres, in glances, with your attention mostly on the lens. That changes what "readable" means:

• Font size should be set from your mark, not from the phone. Walk back, read a line, and if there's any lean or squint, go bigger. On a phone at two metres, comfortable usually means only a handful of words per line — which feels absurd at arm's length and is exactly right from your mark.
• Fewer words on screen is a feature. Big text means less visible script, which worries people. But you read a phrase at a time anyway, and a good prompter keeps your place; a screen crammed with small text just gives your eyes more places to get lost.
• Contrast does the work your eyes can't. Light text on a near-black background, and a position highlight bold enough to find in peripheral vision. If your setup involves any glass, assume half the contrast is gone before it reaches you.
• The typeface is allowed to help you. If you find reading aloud under pressure difficult, a face designed for it changes the experience: TellyPrompter ships OpenDyslexic as a first-class script face with the same size range as the default, because for plenty of readers it's simply the difference between a script they can perform from and one they can't. And no cue in the app is carried by colour alone, so losing the colour distinction — as roughly one in twelve men do — never means losing your place.

Mirror mode and rotation

Two settings exist specifically for rigs, and both live in software.

Mirror mode flips the display horizontally so that a reflected script reads correctly. Any mirror or beam-splitter rig needs it. Check it with a real sentence in the glass, not just a glance — and notice that the whole screen flips, controls included, so left on screen is right in the glass.

Rotation matters for phones locked to portrait. Some rigs and mounts want the screen turned 90 degrees, and if the phone's own rotation lock is on — as it often deliberately is during a shoot — the software needs its own rotation control. TellyPrompter has one for exactly this case.

One habit worth building: set mirror and rotation before mounting the phone. Fishing a phone out of a hood to reach a setting gets old on the first shoot day.

Running the take when you can't touch the phone

Once the phone is in a rig at your mark, it's effectively out of reach: your hands are in frame, the screen may be behind glass, and walking over to poke it means re-settling into position for every take.

This is where the scroll mode decides your day. A constant-speed scroll set by guesswork has no mid-take correction available — the phone is untouchable, so a wrong speed means chasing the text or abandoning the take. A voice-following mode removes the problem at source: TellyPrompter listens as you read and keeps a highlight on the word you're saying, through pauses, ad-libs and backtracking, so there's no speed to have set wrongly. Speech recognition runs on the device and the audio is never uploaded.

Voice commands close the remaining gap. "Telly, stop" ends a take from your mark; "Telly, again" starts a retake; "Telly, marker" drops a marker where you stumbled, so you know what to check afterwards without touching anything. The one limitation to know: voice features depend on the browser's speech recognition, which Firefox doesn't implement — there, the sound-level and constant modes still work, and everything else is unaffected.

Same phone, or a second device?

Recording on the prompting phone is the simplest possible rig: one device, script and camera together. TellyPrompter records in-app with the script and camera preview sharing the screen — the split between them is draggable, because how much of yourself you need to see is your call, not the app's. The trade-off is that the phone doing everything is also the phone whose camera position is fixed by where you can read from.

A second device separates the jobs: your best camera shoots, the phone prompts beside or behind it. This is the natural shape for mirror and beam-splitter rigs, and it frees the camera to be a camera — any distance, any lens. The cost is a little more setup and syncing the footage in the edit.

There's no wrong answer; there's a distance answer. At arm's length to a metre and a half, one phone does it all. Beyond that, the propped-phone eye line starts to show, and a second device plus a rig is the upgrade path.

Settings checklist, per setup

Propped phone: camera as far back as the room allows; font size set from your mark; dark background; voice-following on so a pause doesn't cost you your place.

Clip-on mirror rig: all of the above, plus mirror mode on and verified with a real sentence; rotation set if the mount turns the phone; settings finalised before the phone goes in the hood.

Beam-splitter: all of the above, plus contrast set boldly enough to survive the glass losing a third to half the light; a key light brighter on your face than the screen's glow; one full read-aloud from your mark before the first take.

Whatever the rung, the test is the same two minutes: stand where you'll perform, read half the script aloud, and see whether the text kept your place without your hands or your feet moving. When it does, the rig has done its job — the rest is delivery.

If you have ever watched a take back and winced at a voice that did not sound like yours, this is for you. Nothing here needs acting training or expensive kit. It needs a script written the way you actually speak, a rig set up so your eyes stay still, and a prompter that does not make you chase it.

The real cause: you are performing to the scroll

Here is the thing nobody tells you when you first prop a script behind a lens. A conventional teleprompter asks you to guess a scroll speed — a words-per-minute number — before you have said a word. Then you spend the whole take serving that number.

Speak a little too slowly and the text creeps ahead of you, so you speed up to catch it. Pause for effect and the pause costs you your place. Stumble, and the script sails on without you while you decide whether to stop or bluff. Your brain is doing two jobs at once: saying the words, and constantly recalculating where you are against a conveyor belt.

That second job is what sounds wooden. The flatness in your voice is not a lack of talent — it is divided attention. The part of you that would normally add warmth, emphasis and natural rhythm is busy doing arithmetic.

You can hear this in the pacing of a struggling read: every sentence comes out at the same speed, because the scroll only has one speed. Real speech does not work like that. You rush the throwaway bits and lean into the point. A fixed scroll flattens both into the same tempo.

There are two ways out. The first is practice — genuinely, people do learn to ride a fixed scroll, the way newsreaders do, and the techniques below will get you most of the way. The second is to remove the conveyor belt entirely. This is the problem TellyPrompter was built around: it listens as you read, and the highlight follows the word you are actually saying — through pauses, ad-libs, skipped lines and backtracking — so the pace of the take is set by your delivery rather than a number you guessed. Speech recognition runs on the device and the audio is never uploaded. Either route works; the rest of this article helps with both.

Write for the mouth, not the page

A large share of wooden reads are wooden before anyone presses record, because the script was written to be read silently rather than said aloud. Written English and spoken English are different registers, and the gap between them is exactly what audiences hear as "reading".

A few changes make a script performable:

Use contractions. "Do not" and "cannot" are fine on the page and stilted out loud. If you would say "don't" in conversation, write "don't". Read any sentence that feels stiff and ask whether you would ever say it to a friend across a table.

Shorten the sentences. A written sentence can carry three clauses comfortably. A spoken one usually cannot — you run out of breath, or the intonation goes strange as you try to signal a comma with your voice. One idea per sentence. Full stops are free.

Break lines where you would breathe. Format the script in short lines rather than dense paragraphs. Each line becomes a natural phrase, and the line breaks do some of your pausing for you.

Say it before you save it. The single most useful edit is reading the draft aloud once and changing every phrase you trip on. If your mouth resists a sentence in rehearsal, it will resist it harder on camera.

None of this is about dumbing anything down. It is about writing in your own speaking voice, which is the voice your audience clicked for.

Eye line and distance: why glancing reads worse than it feels

The camera is unforgiving about eyes. A glance away that feels tiny to you — down at notes, sideways at a second screen — reads on camera as evasiveness or distraction. This is why the physical setup matters more than most delivery advice.

The distances involved are smaller than you might think. If your script sits right next to the lens rather than over it, the angle between "looking at the script" and "looking at the viewer" shrinks as you move the camera back. At arm's length, the flick of your eyes between the two is visible. At two or three metres, it mostly is not.

So: put the script as close to the lens as your setup allows, and put the camera further away than feels natural, then zoom or crop back in. If you use a beam-splitter rig — the mirrored glass that puts the script directly over the lens — the problem disappears entirely, because reading and eye contact become the same act. That is why those rigs exist — and if you are thinking of building one, we have written a full beam-splitter setup guide.

Two practical notes for prompter glass. The mirror flips everything, so make sure your software has a proper mirror mode rather than asking you to read backwards. And the glass eats a surprising amount of light — roughly a third to a half — so favour large text and strong contrast over anything subtle.

Text size matters at ordinary distances too. You want the script readable in your peripheral vision, in glances, without leaning in. Bigger than feels necessary is usually right. Squinting shows.

Rehearse once aloud — then stop

There is a sweet spot between under-prepared and over-prepared, and it is closer to under than most nervous people believe.

Read the script aloud exactly once before you record. Not in your head — aloud, at performance volume, standing or sitting as you will on camera. Two things happen. First, you find the stumbles: the phrases your mouth does not like, the sentence that runs out of breath. Fix those in the script now, rather than discovering them on take four.

Second, you take the edge off the newness. The first read of any script is always the most careful and the most wooden. Spend that read off camera.

Then resist the urge to keep rehearsing. Past one or two reads, something worse than unfamiliarity creeps in: memorisation. Once you half-know the script, you start reciting from memory and using the prompter to check yourself, which produces its own strange cadence — the sound of someone confirming rather than saying. The prompter works best when you trust it completely and let each line be slightly new.

Mark, don't memorise. If a section worries you, put a cue in the script — an underline, a deliberate line break before the hard word — rather than drilling it.

Ad-libbing without losing your place

The moments audiences remember are usually the off-script ones — the aside, the joke that occurred to you mid-sentence, the plainer restatement of a point that came out better than the written version. A teleprompter should permit those, not punish them.

On a fixed scroll, ad-libbing costs you. Every second off script, the text keeps moving, and the price of the aside is a scramble to find your line. Which is why heavily prompted speakers so rarely deviate: not because they have nothing to add, but because the tool taxes it.

If you are riding a fixed scroll, the workaround is to plan your departures: write a short cue like "story about the first attempt" into the script itself, and keep the aside brief enough that the scroll has not travelled far. Some speakers keep a remote or foot pedal to pause the scroll — workable, but one more thing to operate mid-take.

A voice-following prompter changes the economics here: when you wander, the highlight simply waits, and when a phrase from the script comes back out of your mouth, it picks you up again. The aside becomes free.

Either way, give yourself permission in the script. A marked "go off-script here" beat, even just once per video, loosens the whole read — because a script you are allowed to leave stops feeling like a cage.

When to stop polishing and take the take

Perfectionism is the last trap, and it is a delivery problem disguised as a quality standard.

The tenth take of a script is rarely the best one. Fatigue flattens your voice, the words go stale in your mouth, and self-consciousness compounds — by take eight you are no longer performing the script, you are performing "not messing up", which is a different and worse energy.

Some rules of thumb that help:

A stumble is not a failed take. Real speech contains restarts and corrections; leaving small ones in usually reads as human rather than sloppy. If a flub genuinely needs fixing, note where it happened, finish the take, and re-record that sentence rather than the whole script.

Two clean-enough takes beat six perfect attempts. Record the full piece twice and choose in the edit. Deciding "this is a selection problem, not a performance problem" takes enormous pressure off each individual run.

Watch for the fatigue signs. When you start making new mistakes in sections you previously nailed, you are done for now. Tea, walk, come back.

The wooden sound you are trying to avoid is, at bottom, the sound of self-monitoring — a speaker split between saying the words and supervising themselves saying the words. Everything in this article serves the same end: script, setup and software arranged so that supervision is unnecessary, and the whole of your attention is free to just talk to the person on the other side of the lens. That is all sounding natural has ever been.

This is a working system for that day: how to prepare the scripts, the order to shoot them in, the loop that keeps takes moving, how to protect your energy through take six, and what to capture so the edit is sorting rather than archaeology.

Why batching works

Every recording session carries a fixed cost that has nothing to do with the video: lights positioned, camera framed, prompter mounted and mirrored, font size checked from your mark, sound tested. Do that weekly and you pay it weekly — often twenty minutes of setup for fifteen minutes of recording.

Batching pays the setup cost once and spends the rest of the session on the only part that actually needs you on camera: delivery. There's a second, quieter benefit — consistency. Five videos shot in one session share light, framing, hair, energy and room tone, which makes them easier to edit and makes a channel look deliberate.

The precondition is that the scripts exist before the day. A batch day that includes writing is two jobs pretending to be one, and the writing always eats the shooting.

Preparing the scripts: a library and an order

Write everything in advance, and give each script one read-aloud pass in the days before — out loud, changing every phrase you trip on. (The full method is in how to write a script you can actually say out loud.) By shoot day the scripts should be performable, not just finished.

Then stage them where the shoot needs them. TellyPrompter's script library holds each script with a tag, so a "This batch" tag turns shoot day into a queue: every script one tap away, nothing to paste mid-session, and last week's material filtered out of view. Loading the next script is a ten-second gap between videos rather than a hunt through documents.

The order matters more than it seems:

• Front-load the hard one. Whichever script you're dreading — longest, most technical, most personal — goes first, while your energy and patience are at their peak. Every script after it feels downhill.
• Warm up on a throwaway. Before the hard one, spend five minutes reading something that doesn't count. The first read of any session is the stiffest; spend it where it costs nothing.
• End on the easiest. A short, familiar format at the end means finishing on a good take rather than a tired compromise.

The shoot-day loop: take, retake, move on

The engine of a batch day is a tight loop per video, and the enemy of the loop is friction — anything that means walking to the rig, touching the phone, or re-settling into position.

A workable loop looks like this. Load the script. Read the first paragraph aloud once as a level and pace check. Take the take, all the way through, without stopping for small stumbles. If it needs another pass, retake immediately while the script is warm — saying "Telly, again" starts the retake from your mark, no walk to the rig. Two usable takes, then move on.

Two habits keep the loop honest:

Mark stumbles instead of stopping for them. A flub mid-take doesn't need a restart; it needs a note. Saying "Telly, marker" drops a marker at that moment and the take keeps rolling — the stumble report afterwards shows you exactly where the rough spots were, so "was that take clean?" gets an answer without scrubbing back through the footage between videos.

Cap the takes. Two, at most three, per script. The tenth take is rarely the best one, and on a batch day it also taxes every video after it. If a script isn't landing in three takes, the problem is usually the writing — park it, shoot the next one, and come back at the end with fresh eyes or a red pen.

TellyPrompter's batch mode is built around exactly this loop — the session moves from script to script without returning to setup between them, which sounds minor and saves its minutes on every single video.

Keeping energy through take six

Delivery energy is a budget, and batch days spend it fast. The audience for video five deserves the same person who showed up for video one; these things protect that:

• Real breaks, on a schedule. Five minutes off camera every two or three videos, before you feel you need them. Off camera means away from the rig — the pause between takes doesn't count.
• Water within reach, not in shot. Reading aloud for an hour dries you out audibly.
• Stand up between videos even if you shoot seated. Posture collapses gradually and reads on camera before you feel it.
• Watch for the tell. When you start fluffing lines you'd previously nailed, the session is over — new mistakes in old material is fatigue, not carelessness, and no take shot past that point survives the edit anyway. Better to finish a five-video day with four good ones than push through to five tired ones.
• Rehearsal mode for the nervy script. If one script has a section you keep worrying about, run it once in rehearsal — a pass that doesn't record — rather than burning performance takes on rehearsing.

Capture for the edit: sorting, not archaeology

The edit for a batch day starts days later, when you remember nothing. The goal on shoot day is to leave your future self a labelled pile rather than a mystery.

Most of that labelling can happen as a by-product of shooting. Markers dropped mid-take become a map of every rough moment. The stumble report per take answers "which of the two takes was cleaner" at a glance, and each take's timing is kept, so you also know which was tighter. Ending the take writes the file — in TellyPrompter, finishing a take, disarming the camera or leaving for the library all save the recording, so a perfect performance can't end with no file.

Captions are the other edit-day gift. Because the prompter follows your voice word by word, it can export SRT or VTT caption files built from the script and your actual timing — script-accurate, no transcription pass, no mis-heard words to fix. Export them on shoot day while the takes are named and fresh, and the edit inherits captions for free.

Beyond the app: keep filenames or a one-line note per video ("v3 — take 2 is the keeper"), and shoot ten seconds of room tone once for the whole session.

The one-page batch-day checklist

Before the day: scripts written and read aloud once each; tagged into a batch queue; order set (warm-up, hardest, easiest last); rig checked — mirror mode, font size from your mark, mic level.

Per video: load script → one-paragraph level check → take → mark stumbles, don't stop → "Telly, again" if it needs a second pass → check the stumble report → export captions → next script.

Per hour: break off camera; water; stand; posture check.

End of day: confirm every video has a take you'd ship; note the keepers; room tone; charge everything for next time.

The point of all this structure is a paradox worth keeping in view: the system exists so that the performance can be unsystematic. When the scripts are ready, the queue is loaded and the retakes are one spoken word away, the whole of your attention is free for the only thing a batch can't prepare in advance — sounding like yourself, six times in a row.

This piece gives you the four-block structure that underpins almost every talking-head video that works, the read-aloud pass that makes it performable, the formatting habits that help you breathe, and a worked example taking one script through the whole process.

The four blocks: promise, idea, proof, next action

Strip the platform advice down to what it agrees on, and nearly every effective short video has the same skeleton:

1. The promise. What the viewer gets, stated immediately. Not a greeting, not who you are, not "in today's video" — the first sentence delivers or previews the value the title promised. If someone reads only your opening two lines, they should know what they'll learn.
2. One useful idea. One. The most common script problem isn't bad writing, it's three videos trying to share one runtime. If you find a second idea in the draft, you've found your next video.
3. Proof. An example, a demonstration, a before-and-after, a moment from your own experience — something concrete that shows the idea rather than restating it. This is the block that separates advice from assertion.
4. One next action. A single closing beat: try this today, watch the follow-up, tell me what happened when you tried it. Not every video needs a conversion ask; a clean takeaway is a perfectly good close. But two asks compete and both lose.

The blocks are a checklist, not a straitjacket — a personal story might spend most of its time in proof; a quick tip is mostly idea. What the structure buys you is the ability to diagnose a limp draft: it's almost always a missing promise, a second idea, or proof that's really just the idea again in different words.

The read-aloud pass

This is the edit that matters most, and it takes ten minutes.

Read the whole draft aloud, at performance volume, and change every phrase your mouth resists. Not skim-mumble — actually say it, as you would on camera. The test for each sentence is brutal and simple: would I ever say this to a friend across a table?

Written English fails that test constantly, in predictable ways:

• Uncontracted verbs. "Do not", "it is", "you will" — fine on the page, stilted aloud. If you'd say "don't", write "don't".
• Sentences with three clauses. You'll run out of breath, or your intonation will go strange trying to voice the commas. Split them. Full stops are free.
• Words you'd never speak. "Utilise", "in order to", "individuals", "however" at the start of a sentence. Your speaking vocabulary is smaller than your writing vocabulary, and the audience clicked for the speaking one.
• Throat-clearing. "So, before we get into it, I just want to quickly mention" — six words of it survive in speech ("quick note first"), the rest is the page talking.

Everything that trips you in this pass will trip you harder on camera, with a light on and a take running. Fix it now, in the cheap medium.

Short lines and breaks as breathing marks

How a script looks on the prompter shapes how it sounds out of your mouth.

Format in short lines — one phrase or one clause per line — rather than dense paragraphs. Each line break becomes a natural micro-pause, so the layout does some of your pacing for you, and a short line is far easier to take in at a glance from two metres away. A paragraph break is a bigger breath: use one wherever you'd pause to let a point land.

Two related habits: put a deliberate break before a hard word or a number, so you arrive at it settled rather than mid-flow; and if you plan to depart from the script — an aside, a story you'll tell freely — write the departure in as a short cue line ("story: the first attempt") rather than scripting it. A script you're allowed to leave stops feeling like a cage, and a voice-following prompter will keep your place and pick you up when you return to the written words.

Two or three hooks, not three scripts

The opening seconds do disproportionate work, so give the opening options — but only the opening.

Once the body is written, draft two or three alternative first lines for the same script: a question ("why do your takes sound nothing like you?"), a direct promise ("this is the edit that makes a script performable"), a contrarian statement ("most script advice makes you sound worse"). Record the body once; record the hooks as separate short takes if you like, and choose in the edit.

This is far cheaper than generating whole alternative scripts, and it respects what's actually uncertain: the body either works or it doesn't, but which door into it suits the platform and the mood is genuinely hard to predict. Keep the hooks honest — a question the video answers, a promise it keeps.

Durations are presets, not promises

You'll see confident claims about the ideal length for a Reel, a Short, a LinkedIn video. Treat all of them as targets to write towards, not rules that predict anything — the platforms themselves say appropriate length depends on the content, and their guidance changes.

The practical use of a target duration is as a writing constraint: aiming at 60 seconds forces the one-idea discipline better than any editing advice. But the number that actually matters is your read time, at your pace, which is usually slower than you'd guess once real pauses are in. Measure it by reading aloud — TellyPrompter shows a measured read-time for a script and has a rehearsal mode for exactly this pass — and then cut or expand against reality rather than against a words-per-minute rule of thumb. When the read runs long, cut the idea's second example before you speed up your delivery; a rushed read costs more than a longer video.

Worked example: one script through all five steps

Say the video is "why your camera batteries die faster in winter", aiming at a 60-second target.

First draft, first lines (written English): "Hi everyone. Today I want to talk about something that affects a lot of content creators during the colder months, which is the fact that battery performance can be significantly reduced in low temperatures."

Blocks check: the promise arrives in sentence three; there's a second idea lurking in the draft about storing batteries, which becomes its own video; proof is currently a restatement ("they really do drain faster") and needs the concrete version — the shoot where two batteries died in twenty minutes; the close asks viewers to like, subscribe and comment, which is three asks.

After the read-aloud pass: "Your camera batteries aren't broken. Cold just drains them faster — and there's a cheap fix. Last January I lost two batteries in twenty minutes on one shoot. Here's what changed. Lithium batteries slow down as they get cold. Keep the spare in an inside pocket, not the bag. Body heat is enough. Swap warm for cold; the cold one recovers as it warms back up. Try it on your next cold shoot, and tell me how long they lasted."

Formatted for the prompter: each of those sentences on its own line, a paragraph break before "Here's what changed", and a cue line — "(show the pocket)" kept visually distinct from the spoken text.

Hooks drafted: the direct version above; a question ("why did both my batteries die in twenty minutes?"); a contrarian ("stop buying more camera batteries").

Measured: read aloud once, it comes to about 50 seconds at a real pace — room to breathe inside the 60-second target, so nothing gets rushed.

That's the whole method. Structure to diagnose, the read-aloud pass to translate, layout to breathe, options where the uncertainty really lives, and your own measured read as the only duration authority. The script that survives it will be shorter, plainer and less impressive on the page than your first draft — and it will sound like you, which is the entire job.

They're organised by job rather than by platform, because the same structure becomes a TikTok, a Reel, a Short or a LinkedIn video just by changing its target duration and its close. All eight ship as starter templates in TellyPrompter, pre-filled so you can read one, replace the words with yours, and take the take.

Why structure beats length

The question people ask is "how long should the video be", but length is downstream of a better question: what job is this video doing for the viewer? Teaching one thing, fixing a pain, walking a process, answering a person, showing a product, telling a story, taking a position, or opening something longer — each job has a shape that works, and the shape tells you what to write next when you stall.

A structure is also what makes a format repeatable. One good "quick tip" is a video; a quick-tip structure you can refill weekly is a series, and series are what audiences actually subscribe to.

The durations below are targets to write towards, not promises about performance — appropriate length depends on the content, and your own measured read time is the only number that decides.

1. Quick tip

The job: teach one immediately useful thing. Target: 15–60 seconds.

The skeleton: direct promise → the tip → a miniature example → takeaway or next action.

Filled: "Your prompter font is too small — here's the fix in ten seconds. Set the size from where you'll actually stand, not from the desk. I read a line from my mark; if I lean in, it goes bigger. Try it before your next take and watch your eye line settle."

The discipline is the single tip. If a second one creeps in, it's next week's video.

2. Problem to solution

The job: help a viewer recognise and fix a pain. Target: 30–60 seconds.

The skeleton: relatable problem → why it happens → the solution → the result → next step.

Filled: "You sound flat on camera and you can't work out why. It's usually not you — it's the scroll. A fixed-speed prompter makes you perform to a metronome, and the flatness is your attention split in two. Let the script follow your voice instead, and the take relaxes. Next video: the settings that make it work."

The relatable problem must genuinely be relatable — the viewer's own words for it, not yours.

3. Three-step how-to

The job: teach a repeatable process. Target: 45 seconds–3 minutes.

The skeleton: the outcome first → step one → step two → step three → recap.

Filled: "By the end of this you'll have a phone teleprompter rig for under thirty pounds. Step one: the hood — here's the one I use and why. Step two: mirror mode, set before the phone goes in. Step three: font size from your mark. That's it — hood, mirror, size — and you're reading straight down the lens."

Outcome first is what earns the steps. Three is a shape, not a law — but past five, it's a course, not a video.

4. Answer a comment

The job: turn audience demand into content. Target: 15–60 seconds.

The skeleton: show or paraphrase the question → direct answer → the nuance or an example → invite the next question.

Filled: "Sam asks: does a teleprompter work if you wear glasses? Yes — with two adjustments. Raise your key light and tilt it down, and use a dark background so there's less screen to reflect. Here's what mine looks like on camera. What should I answer next?"

Answer first, nuance second. Making them wait for the answer is the one way to waste this format — and the platforms treat comment replies as a native workflow, so the demand is already measured.

5. Product demo

The job: show how something works. Target: 30–90 seconds.

The skeleton: the problem or use case → the thing in action → the benefit made visible → an honest limitation or who it's for → next action.

Filled: "Recording alone means nobody's operating the prompter. Watch what happens when I pause mid-sentence — the script waits. When I ad-lib — it waits again, then picks me up. That's a take with no operator. It does need a browser with speech recognition, so not Firefox. Link below if your rig needs this."

The honest limitation isn't a courtesy, it's what makes the rest believable. If you can't name one, you haven't used the product enough to demo it. (If the demo is sponsored, that's a different structure with disclosure obligations — deliberately not this one, and covered properly in a follow-up piece.)

6. Personal story with a lesson

The job: build connection without rambling. Target: 60 seconds–3 minutes.

The skeleton: a moment of tension → what changed → one specific detail → the lesson → the viewer's takeaway.

Filled: "Take eleven, and I was getting worse, not better. I nearly scrapped the whole video. Then I noticed something in the playback: my eyes, flicking left every four seconds — to the script beside the lens. Moved the camera two metres back, retook it once, done. The lesson wasn't practice; it was setup. If your takes get worse as you go, stop performing and check the rig."

The specific detail — the eyes, the four seconds — is the story. Without it you have a fortune cookie.

7. Opinion or myth correction

The job: state a useful point of view. Target: 30 seconds–2 minutes.

The skeleton: the common belief → your position, plainly → two reasons or examples → a fair caveat → question or close.

Filled: "Everyone says memorise your script so you look natural. I think that advice makes most people worse. Half-memorised is the worst state — you recite from memory and check the prompter, and the checking is what looks shifty. And memorising burns the hours that should go into the writing. Fair's fair: for a 20-second scripted gag, memorising works. For everything else, trust the prompter. Disagree? Tell me why."

The caveat is load-bearing: a position with no conceded ground reads as a pose.

8. The YouTube opening 30 seconds

The job: start long-form without throat-clearing. Target: a 30-second opening; the body is its own script.

The skeleton: meet the title's promise immediately → show the payoff or stakes → preview the route through the video → begin section one.

Filled: "This is a complete beam-splitter setup for one person — by the end you'll have built it and taken a test read. Here's the finished rig, and here's the take it produced. We'll do glass, mount, mirror, light, then the two-minute check. First, the glass, because it decides everything else."

No greeting, no channel biography, no "before we start". The first 30 seconds are measured as their own unit, so write them as one — and put the best material forward rather than saving it.

Adapting one structure across platforms

Resist making four versions of the taxonomy. One structure travels: take the quick tip above, and it's a 15-second vertical clip with a "follow for more" close, a 45-second YouTube Short with a related-video close (a spoken one — links aren't clickable in a Short's description), or a LinkedIn post with a professional-context close. What changed was duration and the final beat; the structure didn't.

Save what works as a series

The last step is the one that compounds: when a structure lands with your audience, keep it. Save the script as a reusable format — in TellyPrompter, that's a script in your library with a tag like "series: quick tips" — and refill it rather than reinventing it. Comparing like with like is also the only honest way to learn what your audience wants: eight videos in one repeatable format teach you more than eight one-offs ever will.

Structure is scaffolding, and scaffolding comes down. Once one of these shapes has carried you through a first take, you'll bend it, and the bent version — the one that fits how you actually talk — is the real template. These eight are just the fastest way to get there from a blank page. For the writing itself — the read-aloud pass that makes any of these performable — see how to write a script you can actually say out loud.

Constant scroll: performing to a number

A constant-scroll prompter asks you to set a speed — words per minute, or a slider — and then moves the text at that speed from start to finish. It's the traditional design, inherited from broadcast, where a dedicated operator rides the speed control by hand while the presenter reads.

Solo, there's no operator, so the number you guessed before the take is the operator. Speak slower than the guess and the text creeps ahead; pause, and the pause spends your margin; ad-lib, and the script has moved on by the time you return; stumble, and you're deciding mid-sentence whether to chase the text or stop the take. The speaker ends up doing two jobs — saying the words and tracking their position against a moving surface — and the second job is what audiences hear as a wooden read.

To be fair to the design: constant scroll has real virtues. It's utterly predictable. It works in any browser, with no microphone, in a noisy room, in silence. A rehearsed presenter who knows their pace can lock a speed and ride it, the way newsreaders do, and for read-along or timed-to-music material a fixed pace is precisely the point. The costs only appear when the read is meant to sound like natural speech, because natural speech doesn't have one speed.

Sound-level scroll: the halfway house

Between the two sits sound-level scrolling: the software advances the text while the microphone hears speech and pauses when you go quiet. It knows that you're talking, but not what you're saying.

That single fact defines both what it fixes and where it breaks. Pauses now work — stop talking and the script stops with you, which removes constant scroll's worst failure. But because it can't match words, it's still moving at a preset rate whenever sound is present, so the drift problem returns in miniature: talk faster than the rate and you catch the text up, slower and it pulls ahead. Ad-libbing advances the script even though you've left it, since your aside is just more sound. And anything else the microphone hears — a passing lorry, a cough — reads as speech.

It's a genuine improvement for a steady reader in a quiet room who mainly needs pauses respected, and it's the right fallback where full recognition isn't available. It's not the same thing as being followed.

Voice-following: the page keeps your place

A voice-following teleprompter listens to the words themselves. Speech recognition transcribes what you're saying, the software matches it against the script, and a highlight sits on the word you're actually speaking. The scroll is a consequence of the match: the text moves because you've moved through it.

What that changes, concretely:

• Pauses are free. Stop to think for ten seconds; the highlight waits on your word.
• Ad-libs are free. Wander off script for an aside and nothing moves; when a phrase from the script comes back out of your mouth, the highlight picks you up where you resumed.
• Skipped lines don't strand you. Decide against a paragraph mid-take and jump past it; the match follows you to where you actually went.
• Backtracking works. Retake a sentence you fluffed and the highlight goes back with you.
• Pace variation is the point, not a problem. Rush the setup, slow into the payoff — the scroll does the same, because it has no opinion about speed.

The practical consequence is that the second job disappears. There's no position to track against a moving surface, because your position is wherever you are. This is what TellyPrompter does, and it's the difference the whole product is built around: scroll speed is the read, not a setting.

What voice-following cannot do

Honesty section, because the technology has real edges.

Recognition quality belongs to the browser, not the prompter. Voice-following in a web app is built on the browser's speech recognition. That engine cannot be tuned by the software using it, and its accuracy varies by platform, by language and by microphone. A language the engine handles poorly, or a very echoey room, degrades the following — the practical test is always the same: paste a real script and read a paragraph aloud.

Firefox doesn't implement it at all. Firefox has no Web Speech API, so voice-following isn't available there — no prompter running in Firefox can offer it. In TellyPrompter, everything else still works in Firefox, and the constant and sound-level modes still scroll; the product degrades rather than blocking. But the listening mode needs a browser that can listen.

It follows a script; it doesn't take dictation. The match needs written words to match against. Fully improvised speech has nothing to follow — though that's not a prompting job in the first place.

Heavy departures take a moment to re-match. Return from a long ad-lib mid-way through a paragraph you never started, and the software needs a phrase or so of script-matching speech to lock back on. In practice you notice this as a beat, not a failure — but it isn't telepathy.

On-device recognition and the microphone question

A teleprompter that listens raises an immediate and fair question: where does the audio go?

For TellyPrompter, the answer is the one sentence that can be said without qualification: speech recognition runs on the device and the audio is never uploaded. The matching happens where the microphone is; there is no server transcribing your takes.

If you're evaluating other voice-following software, it's worth asking the same question directly, because architectures differ — some products do send audio to a server for recognition, which may be a perfectly acceptable trade for you, but it's one you should get to make knowingly, especially for unreleased or client material.

Which to choose for which job

Choose constant scroll when the read is rehearsed and paced — you know your speed and can hold it; when the material is timed to something external, like music or a broadcast slot; when you're in Firefox or a browser without recognition; or when the room is too loud or the language too poorly supported for the match to hold.

Choose sound-level when you mainly need pauses respected, the room is quiet, and full recognition isn't available or isn't holding.

Choose voice-following when the read should sound like natural speech — which for a solo creator recording themselves to camera is nearly always. Pauses, ad-libs, retakes and nerves are the normal texture of that work, and this is the mode that treats them as normal rather than as errors. It's also the mode that changes what a script is: less a track to stay on, more a floor to come back to.

The good news is that this isn't a purchase decision, it's a toggle. TellyPrompter includes all three modes on the free tier, so the honest way to settle it is empirical: same script, one read in each mode, including one deliberate pause and one deliberate ad-lib. The mode that kept your place through both — and left your attention free for the lens — is the answer. For what to do with that freed attention, see how to read a teleprompter without sounding wooden.

This piece explains how offline works for a web app, what still functions with no signal, what doesn't, and the five-minute preparation that makes the question irrelevant by the time you're on location.

The room with bad wifi is a normal room

Shoot locations are chosen for light, quiet and backdrop — never for signal. The spare room at the back of the house, the borrowed office at the weekend, the village hall, the car park where the light is good at four o'clock: these are ordinary places to record, and they are reliably terrible places to be online.

A teleprompter has a particular relationship with this problem, because it fails at the worst possible moment. You're set up, lit, framed and settled, and the tool that holds your script won't load. Most software treats connectivity as a given; a prompter built for real shoots has to treat its absence as the normal case. That assumption shaped TellyPrompter from the start — the first requirement was opening in a room with bad wifi, which is why the whole app is small enough to arrive on a weak connection and structured to stop needing one.

What "offline" means for a web app

A website that works offline sounds like a contradiction, so here's the actual mechanism, briefly.

Modern browsers support two things that together make it real. The first is installation: a progressive web app (PWA) can be added to your home screen or desktop from the browser — no app store — after which it opens full-screen like any installed app. The second is a service worker: a small programme the site leaves behind in your browser, which stores the app's files locally and serves them itself. Once it's in place, opening the app doesn't fetch anything; the copy on your device loads, connection or none.

The one structural consequence: the first visit must be online. The service worker and the app's files have to arrive over the network once before they can be served locally. There's no way around that first fetch — which is why the preparation section below exists, and why the golden rule is simple: first visit at home, every visit after that anywhere.

Your scripts, meanwhile, live in the browser's local storage on the device — they were never on a server to begin with, so the library is as offline as the app is.

What works with no network, and what doesn't

Works offline, once installed:

• Opening the app and your whole script library — pasting new scripts, editing, tagging
• All three scroll modes. Constant and sound-level scrolling have no network involvement at all; voice-following uses the browser's on-device recognition — speech recognition runs on the device and the audio is never uploaded — so there's no server in the loop to lose. (Recognition itself remains the browser's: quality varies by platform and language, and Firefox doesn't provide it at all, connection or none.)
• Mirror mode, rotation, and every display setting — all stored on the device
• In-app recording. The camera, the microphone and the file are all local; a take recorded in a field is written the same as a take recorded on fibre
• Caption export (SRT/VTT) and script export — generated on the device from data on the device

Needs the network:

• The first visit, as above — and after an update ships, an online open picks up the new version, but a stale offline copy keeps working in the meantime
• Google Docs import. Fetching a document is a network request by nature. Import the doc while you're connected and it's in your library; the library needs nothing thereafter
• File import from cloud storage — a .docx in your email or drive needs downloading first, though a file already on the device imports fine offline
• Account and sync features. Signing in and Pro's cross-device library sync talk to a server, so a lapsed connection defers sync until you're back online — the local library carries on regardless

The pattern is deliberate: everything on the path from script to take is local, and the network-touching features are the ones that fetch from or push to somewhere else by definition.

The prepare-before-you-go checklist

Five minutes at home removes every failure mode above:

1. Install the app — open TellyPrompter in the browser and add it to your home screen or desktop. This is the step that plants the offline copy.
2. Load every script for the shoot. Paste them, or run any Google Docs imports now, while the network exists. Tag them for the session so they're one tap apart on the day.
3. Open the app once from its icon and confirm the scripts are there. You've just rehearsed the exact thing you'll do on location.
4. Test the mic and camera once — grant the permissions at home, not standing at your mark.
5. Airplane-mode dress rehearsal. Turn the connection off, open the app, start a take, read a paragraph. Thirty seconds, and the question "will this work out there?" is answered empirically rather than hopefully.

That last step is the one people skip and the one worth keeping: it converts every claim in this article into something you've watched happen on your own device.

Degrade, never block

The design principle underneath all of this is worth stating, because it's checkable against behaviour: losing a capability should remove that capability, and nothing else.

No network takes away imports and sync, and leaves a complete prompter. No speech recognition — Firefox, or an unsupported language — takes away voice-following, and leaves two other scroll modes. No camera permission takes away recording, and leaves the prompter. No microphone takes away voice mode and recording sound, and the constant scroll still runs. At every step the answer to "can I still do the take?" is yes, with one fewer convenience.

That's the property that matters on a shoot day, more than any single feature: the tool's failure modes are subtractions, not stoppages. The room with bad wifi stops being a risk you plan around and becomes just a room — which, given how shoots choose their rooms, is exactly as it should be. If the software half of your rig is still an open question, voice-following vs constant scroll covers the other decision that shapes the day.

Free means the prompter

Here's the complete list of what works with no account and no payment, because the list is the claim:

• All three scroll modes — voice-following (the script tracks the word you're actually saying, through pauses, ad-libs and backtracking), sound-level, and constant scroll. The voice-following mode is the reason the product exists, and it is not held back.
• 34 languages, left-to-right and right-to-left, with automatic detection — and OpenDyslexic as a first-class script face, with the same size range as the default.
• Mirror mode and rotation for beam-splitter rigs and portrait-locked phones, plus the full set of display controls: typography, spacing, contrast, active-line position.
• In-app recording, unwatermarked. A take is one press; the file is yours, clean. Nothing about the free tier writes on your video.
• The script library, with tags, stored on your device.
• Import and export. Google Docs import, .docx/.txt/.md upload — and export of every script, in full, on every tier.
• Voice commands and the take tools — "Telly, stop", "Telly, again", stumble markers, the post-take report, measured read-time, and script-accurate SRT/VTT caption export.
• Offline use as an installable app, after one online visit.

The pattern worth noticing: everything on the path from pasting a script to a finished take is in the free tier. What's paid sits beside that path, not across it.

No account on the path

The second half of the claim is the sign-up, and the design here is strict: there is no account on the path from paste to running script. You arrive, you paste, you read. No email gate, no "create a free account to save", no trial clock.

The library is why this works without a catch. Your scripts live in your browser's local storage, on your device — they don't need an account because they were never on a server. The account exists only for people who choose the paid tier, and the one place in the whole app that mentions a price is the account dialog, behind a button on the setup screen. If you never open it, the product never brings it up.

Why build it this way, when every growth playbook says capture the email first? Because the product's own positioning depends on it. A prompter you can hand to a nervous stranger and have running in a minute is a different product from one that opens with a form, and "free with no account" is only a durable claim if the free thing is complete. A hollowed-out free tier would make the sentence marketing; a complete one makes it a description.

What Pro adds, and who it's for

The paid tier is one thing, done properly: an unlimited script library that syncs across your devices.

Sign in, and your scripts live in the cloud as well as on the device — write on the laptop, shoot from the phone, and the library is the same library in both places. The free tier's local storage is per-device by nature; sync is what removes that boundary.

Who actually needs it: someone producing regularly across more than one device, or with a back catalogue of scripts they want kept without thinking about it. A weekly batch-shooter moving between a writing machine and a rig phone is the obvious case. Someone who records occasionally, on one device, plausibly never needs it — and the free tier is not engineered to change their mind.

Pro is £7 a month, £40 a year, or £99 once. That's the only mention of money you'll find in this article, and near enough the only one in the product.

Export shipped before sync, on purpose

One design decision says more about the tier structure than any feature list: export is free, on every tier, for every script — and it shipped before the synced library did.

The reasoning is simple to state: the way out has to be visible before the way in. If your scripts can leave at any time, in full, without payment, then the paid tier has to earn its keep by being useful rather than by holding your work hostage. Lapsing a subscription doesn't strand anything — your scripts remain readable and exportable; what stops is the ongoing sync. The tier boundary is drawn around convenience, not around access to your own writing.

It's worth checking any tool you depend on against this question, whatever you decide about this one: if you stopped paying tomorrow, what happens to the work you've already put in?

The honest limits

These apply to everyone, free and paid, and they're stated here because a piece about what you give up should include the things nobody's tier removes:

• Firefox has no voice-following. Voice mode is built on the browser's speech recognition, and Firefox doesn't implement the API. Everything else works there, and the constant and sound-level modes still scroll — the product degrades rather than blocking — but the listening mode needs a browser that can listen.
• Recognition quality is the browser's, not ours. Speech recognition runs on the device and the audio is never uploaded — and the engine doing it belongs to your browser, so accuracy varies by platform, language and microphone, and no setting in the app can tune it. The two-minute test — paste a real script, read a paragraph — beats any promise.
• The local library has a cap. On the free tier, scripts you haven't tagged are kept up to ten; when an eleventh arrives, the oldest untagged one is evicted from that device. Tagging a script marks it as a keeper, and tagged scripts aren't evicted — with a generous overall ceiling as a backstop so local storage can't silently fill. Anything you care about: tag it, or export it, both free.

None of these is a hook towards the paid tier — Pro inherits the same browser, the same recognition and the same honesty. They're just the true edges of the product.

What you give up, then

Read the lists again and the answer is short. Using TellyPrompter free, without an account, you give up cross-device sync and the unlimited cloud library. You keep the entire prompter: every scroll mode, every language, the rig features, recording without a watermark, your library on your device, and a full exit through export at any time.

Whether that trade suits you depends on how you work, and the honest way to find out costs nothing and asks for no email: paste a real script, stand at your mark, and take a take. The product's bet is that the take is what convinces — and if it does, and you happen to make videos about camera gear for a living, the affiliate programme exists for exactly that conversation.

This guide walks the four setup tiers honestly, cheapest first, then covers the software side properly. A prompter scrolling at the wrong speed makes expensive glass useless, and a prompter that follows your voice makes cheap glass work.

Start with distance, not budget

Before comparing kit, stand where you actually record and look at where the camera goes. The distance between you and the lens decides more than any spec sheet.

At arm's length — a desk setup, a laptop, a phone on a small tripod — your eyes travel a visible distance between a script beside the lens and the lens itself. Every glance shows. At two to three metres, the same glance shrinks to almost nothing, because the angle between script and lens closes as the camera moves back.

So the question is not "which teleprompter is best" in the abstract. It is: at your distance, does a script next to the lens read as eye contact, or do you need the script on the lens? Everything below follows from that.

Tier one: the propped phone

Cost: nothing you don't already own. Put your script on a phone or tablet, prop it as close to the lens as physically possible, and move the camera further back than feels natural — then crop or zoom back in. The further the camera, the less visible the glance between script and lens.

This is a genuinely workable setup, not a compromise to apologise for. Plenty of channels run on it for years. Its ceiling is the eye line: closer than about two metres, viewers can see you reading, and no delivery technique fully hides it.

If this is where you are, spend your effort on font size and script placement rather than shopping. We've covered the details in the phone teleprompter rig guide.

Tier two: a phone or tablet behind glass

The first real purchase worth making is a beam-splitter hood: a sheet of half-mirrored glass at 45 degrees in front of the lens. Your screen lies flat below it, the script reflects up into the glass, and the camera shoots straight through to your face. Reading and eye contact become the same act, which is the entire reason the category exists.

The smallest hoods clamp a phone below the glass with a second phone or a compact camera behind. A step up, tablet-sized hoods take an iPad as the screen — and the bigger screen is the point, because at two to three metres screen area buys font size, and font size buys a still, natural eye line.

One piece of physics to respect: the glass is expensive to look through. It passes roughly a third to a half of the light in each direction, so your camera loses light and — more importantly — the script you read is dimmer and lower-contrast than the bare screen. Set text larger and bolder than feels necessary, and treat any subtle visual cue as already lost. The beam-splitter setup guide covers mounting, mirroring and lighting in full.

For most YouTube creators recording to camera regularly, this tier is the answer. It removes the glance entirely, it works with kit you largely own, and its running cost is a bit of setup discipline.

Tier three: glass in front of a proper camera

If you shoot on a DSLR or mirrorless camera, the same beam-splitter principle applies with a larger hood sized to your lens. The screen behind the glass is still a phone or tablet running your script; the camera simply gets better.

What changes is the workflow rather than the reading. Recording and prompting become two devices, so you manage the camera's record button and the prompter separately, and the device running the script still needs to hear you if you want voice features. It is the most involved setup on this list and the best-looking footage, and it suits channels where image quality is part of the offer.

Tier four: integrated units

Above the hood-and-your-own-screen tiers sit purpose-built prompters with the display built in — Elgato's Prompter is the best-known example aimed at creators and streamers. You give up the flexibility of using a screen you already own in exchange for a tidier single unit on the desk.

These make most sense for a permanent recording setup used near-daily, particularly at desk distance where their compact size fits. For a rig you assemble per shoot, a tablet hood does the same job for less. If you own or are considering one, the software question below still applies — we've written about pairing prompter software with the Elgato unit separately.

The half the roundups skip: the software

Here is the uncomfortable truth about teleprompter hardware reviews: the glass is the cheap problem. Any competent beam-splitter puts the words on the lens. What happens to those words next is decided entirely by software, and it is where most takes actually go wrong.

A conventional prompter app asks you to guess a scroll speed — a words-per-minute number — before you have said a word, and then plays the script at that speed while you perform to it. Speak slightly slowly and the text creeps ahead; pause for effect and the pause costs you your place; stumble and the script sails on while you decide whether to stop the take. On a beam-splitter this is worse, not better: your hands are in frame, the phone is inside the hood, and there is nowhere to glance for a correction.

The alternative is software that listens. TellyPrompter follows your voice: as you read, a highlight tracks the word you are actually saying, through pauses, ad-libs, skipped lines and backtracking, so the pace of the take is set by your delivery rather than a number you guessed beforehand. Speech recognition runs on the device and the audio is never uploaded. It runs in the browser on whatever screen your rig already uses, mirror mode and rotation included, with text and contrast settings built for reading at one to three metres through glass.

Whichever software you choose, check three things against your rig before trusting it with a take: a proper mirror mode that flips the whole display, not just the text; type that stays readable after the glass has taken its share of the light; and a way to control a take without touching the screen, because on a rig you usually can't.

Delivery matters as much as either half — a well-set rig with a wooden read is still a wooden video. How to read a teleprompter without sounding wooden covers that side.

Which setup for which channel

If you are recording your first scripted videos, start at tier one and spend nothing. The habit of working to camera matters more than the kit, and a propped phone with the camera set well back gets you surprisingly far.

If you record talking-head videos regularly and the reading shows, a phone or tablet hood is the purchase that changes the footage. It is the best value on this list by a distance.

If your channel trades on image quality, tier three: your existing camera behind sized glass, with a tablet as the screen.

And if you record daily at a desk and want the rig to live there permanently, an integrated unit earns its place.

At every tier, run the same check before you press record: stand on your mark, read a line, and ask whether your eyes moved. If they didn't, the hardware has done its job — and the rest of the take belongs to the script and the software.

The honest limits

No teleprompter setup fixes a script written for the page rather than the mouth, and none of the hardware above makes a fixed scroll follow you. On the software side, voice-following depends on the browser's speech recognition, so quality varies by platform and language, and Firefox doesn't implement the API at all — there, constant and sound-level scrolling still work. The glass itself asks only two things: keep it clean, and keep room light off the back of it.

Get the distance right, put the script on the lens if you're close, and let the scroll speed be the read. That is the whole of what "best" means here — the setup that disappears, so the take is just you, talking to the person on the other side of the glass.

This guide covers the ways to rig a tablet, the settings that matter once it's mounted, why a browser-based prompter suits a tablet particularly well, and the small physics of pointing a bright screen at your own face.

Why the tablet earns its place

A phone prompter works — plenty of creators never need more — but it makes one compromise constantly: at a comfortable reading size for two metres, a phone shows only a few words per line. That's workable with a prompter that keeps your place, but it leaves your eyes doing more travelling per sentence.

A tablet roughly quadruples the glass. At the same distance you get either much larger text, or the same text with more of the script visible around it — and larger text is nearly always the right way to spend the space. Bigger type means the script sits comfortably in your peripheral vision while your attention stays on the lens, which is the whole game of reading to camera without looking like you're reading. If you wear glasses, or you find reading aloud under pressure hard work, the extra size is not a luxury.

The other thing the area buys is eye-line forgiveness. With a bigger screen mounted just below or beside the lens, the active line of the script can sit closer to the lens axis than a phone allows, which shrinks the visible glance.

Three ways to mount it

Beside or below the lens. The free option: a tablet stand or a cheap tripod clamp holds the iPad as close to the camera as possible. Same logic as a propped phone — the further back the camera, the less visible the glance — but the tablet's font size makes the whole arrangement work from further away. If you're weighing this against the other setup tiers, the full YouTube setup guide walks the ladder.

A tablet beam-splitter hood. The serious option: a hood sized for tablets puts the iPad flat beneath half-mirrored glass, with your camera behind. The script appears directly over the lens, so reading and eye contact become the same act. Check the hood's stated screen size against your tablet before buying — tablet hoods are physically large, and an iPad in landscape needs the bigger ones. And budget for the glass tax: beam-splitter glass passes roughly a third to a half of the light, so the script you read through it is dimmer and lower-contrast than the bare screen. Set the type larger and bolder than the desk suggests.

Flat on the desk for seated reads. For desk-distance recording — a webcam or phone at arm's length — a tablet angled below the camera works as a compact prompter without any glass at all. The eye line compromise is real at that distance, so keep the script's active area as high on the screen and as close to the lens as the layout allows.

The settings pass, from your mark

Do this once the tablet is mounted, standing or sitting where you'll actually perform — not leaning over the rig.

Font size from the mark. Walk back, read a line aloud. Any lean or squint means bigger. On a tablet the temptation is to keep text modest because the screen can fit so much; resist it. Fewer, larger words with a prompter keeping your place beats a wall of small ones.

Mirror mode, if there's glass. The reflection flips everything horizontally, so the software needs a proper mirror mode — and check it with a real sentence in the glass, since the whole interface flips, not just the words.

Orientation. Landscape suits most hoods and gives the longest lines; portrait suits some desk stands. If the tablet's own rotation lock is on — sensible during a shoot — make sure the prompter software has its own rotation control rather than fighting the OS.

Brightness, deliberately. A tablet is a fair-sized light source pointed at your face. In a dim room it becomes your key light, an unflattering screen-coloured one that also reflects in glasses. The fix is not a dimmer script — through glass you need that brightness — but more light elsewhere: one soft key light brighter on your face than the screen's glow, and a mostly-dark prompter background so the panel throws as little light as possible. Dark background, light text is the rig standard for exactly this reason.

Why browser-based suits a tablet

Here's a quiet advantage of running your prompter in the browser rather than from an app store: the tablet doesn't need anything installed to become a teleprompter. Open tellyprompter.com in Safari, paste a script, and it runs — which matters more on tablets than anywhere else, because the tablet in the rig is often a family device, a work device, or an older iPad kept for exactly this kind of job, and not one you want to manage apps on.

If the tablet is a regular part of your rig, install the site as an app from the browser's share menu. It gets an icon, opens full-screen without browser furniture, and — because it's a PWA with an offline service worker — after the first visit the prompter works without a connection. A shoot in a room with unreliable wifi is a normal place to open a teleprompter, and the tablet rig shouldn't depend on the router.

Settings persist on the device, so the rig remembers its own setup: the mirror choice, the type size you set from your mark, the theme. The one deliberate exception is screen rotation, which resets each session — a rotation you can't escape is worse than one you re-enable — so if your mount needs it, flipping it back on is part of the mounting ritual.

Voice-following works the same on a tablet as anywhere else: read, and the highlight tracks the word you're saying, so there's no scroll speed to have guessed wrongly and no reason to touch the mounted screen mid-take. Speech recognition runs on the device and the audio is never uploaded. The honest caveat travels with it: recognition is the browser's, so quality varies by platform and language, and Firefox doesn't implement the API — there, the constant and sound-level modes still scroll.

A ten-minute setup checklist

1. Mount the tablet — stand, clamp or hood — with the screen's active area as close to the lens as the rig allows.
2. Open the prompter, paste the script, and set mirror and rotation before the tablet goes behind any glass.
3. Walk to your mark. Set the font size from there. Bigger than feels necessary is usually right.
4. Dark background, light text. If there's glass in the rig, bolder still.
5. Key light on, brighter on your face than the tablet's glow. Check glasses for reflections.
6. Read half the script aloud from the mark. If the text kept your place without your hands moving, the rig is done.

The iPad's job in all this is to be a big, bright, silent piece of glass with your words on it. Once the mount is set and the type is sized from where you stand, it should disappear from your attention entirely — and what to do with the attention it frees up is covered in how to read a teleprompter without sounding wooden.

This guide covers choosing a hood for a proper camera, mounting and balancing it, the microphone question that the two-device split creates, and how to actually run takes when the record button and the script live on different machines.

Why this rig exists

At the point where you're shooting on a mirrorless or DSLR body, you've already decided image quality is part of your channel's offer — the lens choice, the depth of field, the low-light behaviour. What the beam-splitter adds is eye contact to match: the script appears directly over the lens, so reading and looking at the viewer become the same act, and the camera's quality is no longer undermined by eyes that visibly track a script beside it.

If you're still weighing this against simpler setups, the YouTube teleprompter guide walks the whole ladder; this piece assumes you've landed here.

Choosing a hood for a proper camera

Camera hoods differ from phone rigs in three ways that matter at purchase time.

Lens compatibility first. The hood mounts around or in front of your lens, so check the maximum lens diameter it accepts and the depth it allows — a long zoom may simply not fit a compact hood. Most camera hoods attach via the tripod thread on a baseplate, with the camera sliding in behind the glass; check your lens sits close enough to the glass to avoid shooting the hood's own edges at wide angles.

Glass size against reading distance. The screen behind the glass is your script surface, and its usable size is capped by the hood. A phone-sized window works close in; if you present from two to three metres, favour a hood that takes a tablet, because screen area buys font size and font size is what survives distance. The glass itself takes its usual tax — roughly a third to a half of the light in each direction — which costs your sensor up to about a stop and, more importantly for you, dims the script. Set text bigger and bolder than the bare screen suggests, and keep room light off the back of the glass. The full physics and lighting treatment is in the beam-splitter setup guide.

Weight and balance. A hood, glass, phone and camera together are front-heavy. Use a tripod head rated for the total, and expect to rebalance the plate the first time — a rig that slowly nods during a take ruins it invisibly until the edit.

Mounting order that saves faff: set the prompter software's mirror mode and font size before the phone goes in the hood, then mount, then fine-tune from your mark. Fishing a device out from under glass to reach a setting gets old immediately.

The two-device workflow

Here is the structural difference from a phone rig: your camera records, and a separate device prompts. Each job gets the best tool, and the camera is free to be a camera — any lens, any distance, proper audio inputs. The costs are a little more setup, and two machines to think about at the top of every take.

The shape that works, take by take:

1. Frame and set the camera first, completely — focus, exposure, audio level — before the prompter enters your attention. The camera's settings shouldn't change again all session.
2. Start the camera rolling and leave it rolling across retakes if your card and battery allow. Cutting the camera between every take doubles your trips behind the rig; one long clip with several takes inside it is cheaper to make and easy to cut later.
3. Run takes from your mark, by voice. With the phone under glass and your hands in frame, the prompter needs to be operable without touching — this is where voice control stops being a convenience and becomes the workflow. Saying "Telly, stop" ends a take from where you stand; "Telly, again" starts the retake; "Telly, marker" drops a note at a stumble so you know what to check without scrubbing footage. The camera keeps rolling through all of it.
4. Clap once at the top of each take. With picture on one device and your working audio on another, a single sharp clap in frame gives the edit an alignment spike. Thirty years of film practice, still the cheapest sync tool there is.

The microphone question

The two-device split creates a subtlety worth getting right on day one: there are now two listeners in the room with different jobs.

Your camera's microphone — usually an external shotgun or a lav feeding the camera — captures the audio the audience will hear. Position it for the recording, as you always would.

The prompting device's microphone is what the voice-following listens to. The script follows you because the device under the glass hears you read; a beautifully positioned shotgun feeding the camera does nothing for the prompter. In practice this is rarely a problem — you're speaking at performance volume a metre or two from the hood, which is exactly the situation device microphones handle — but it explains the one failure mode people hit: recording audio on the camera, phone buried and muted in a case, and wondering why the script won't follow. The prompting device needs to be able to hear the room.

Worth saying plainly while we're on microphones: the listening is local. Speech recognition runs on the device and the audio is never uploaded — the device under the glass is matching your words against the script, not transcribing your takes to a server. And the honest limit travels with the feature: recognition is the browser's, so quality varies by platform and language, and Firefox doesn't implement the Web Speech API at all — there, the constant and sound-level scroll modes still work, and a camera rig runs on them the same way, just with a speed to set beforehand.

Settings that earn their keep on this rig

Mirror mode, verified with a real sentence in the glass — the whole display flips, controls included.

Font and contrast for the glass, set from your mark, not the desk. Light text, near-black background; the dark background also keeps the hood's interior from glowing and washing the image.

A key light brighter than the screen's glow on your face. The prompter is a light source aimed at you; give the camera a better one.

Rotation, if your hood mounts the phone sideways and the phone's own rotation lock is on — the software's rotation control exists for this case.

A first-session checklist

1. Balance the rig on the head; confirm no slow nod with everything mounted.
2. Camera: frame, focus, exposure, audio level. Lock it.
3. Prompter: mirror on, rotation if needed, font sized from your mark, dark background.
4. Hood: no room light striking the back of the glass; wide shot checked for hood edges.
5. Sound check both listeners — a sentence at performance volume; the highlight should follow it.
6. Roll camera, clap, and run half the script as a rehearsal take before the one that counts.

The promise of this rig is worth its setup: your best camera, unbroken eye contact, and takes you run entirely from your mark. When the balance is set, both microphones can hear what they need to and the retake is one spoken word away, the machinery stops being the story — which leaves the footage, and you.

This piece covers the mechanics: where to put your eyes, how to calibrate energy for a medium that flattens it, pacing and pauses, what to do with your hands, and the warm-up that stops take one being the practice run.

The lens is a person

The strangeness of talking to camera is that there's nobody there. Every instinct you've built across a lifetime of conversation — reading a face, adjusting to nods, pausing when someone leans in — gets no input, and the common result is a voice that goes flat and formal, the way people sound leaving a voicemail.

The fix that actually works is concrete, not motivational: picture one specific person on the other side of the lens. Not "the audience" — one viewer. A friend who'd genuinely want this video, a past version of yourself who needed it, a subscriber whose comment you remember. Talk to them. The difference is audible within a sentence, because your speaking apparatus already knows how to talk to one person; it just needs to be told that's what's happening.

A useful side effect: one person changes your word choices. You stop saying "hello everyone, welcome back" — you'd never say that to a friend — and start saying the thing you'd actually say.

Eyes: where they go and why it shows

The camera is merciless about eyes. A glance that feels tiny to you — down at notes, off to a second monitor — reads on screen as distraction or evasiveness, because the viewer experiences your eye line as eye contact with them.

Three working rules:

Look at the lens, not the screen. If you record with your phone or a webcam, the temptation is to watch yourself in the preview. On camera this reads as looking slightly below the viewer's eyes, endlessly. Find the lens, and if it helps, put a small dot or arrow sticker next to it for the first few sessions.

If you read from a script, put the script as near the lens as your setup allows — and the further back the camera, the less any remaining glance shows. This is the entire logic of teleprompter placement, and if reading is part of your workflow, how to read a teleprompter without sounding wooden covers the craft of it in full.

Breaks in eye contact are allowed — if they're human ones. Nobody stares unbroken in real conversation. Looking away to think, glancing down at a prop, turning to gesture at something: these read as natural because they're motivated. It's the unmotivated flick — to notes, to the clock — that reads as reading.

Energy: the camera takes a cut

Here's the unfair physics of the medium: the camera flattens delivery. Energy that feels normal in the room arrives on screen slightly deadened — a combination of compression, small screens, and the missing presence of an actual human body. Speak at genuine conversational level and you'll often watch it back sounding tired.

The working correction is to aim a notch warmer than conversation — not performance, not presenting, just the version of you telling a friend something you're genuinely interested in. More vocal variety than feels necessary, slightly more animation in the face. On camera it lands as normal.

The calibration tool is simple and unglamorous: record thirty seconds, watch it back, adjust. Everyone's correction factor is different, and thirty honest seconds of playback teaches you yours faster than any rule. Most people need to come up a notch; a few natural over-projectors need to come down. You only find out by looking.

One caution at the other edge: pushed too far, energy tips into a presenting voice — the bright, salesy register that audiences flinch from precisely because it isn't talking, it's performing talking. The test is always the same: would you say this sentence, this way, to the one person you're picturing?

Pace, and the pause you're afraid of

Nerves speed people up. The racing read is the most common single fault in self-recorded video: no air between ideas, sentences piling into each other, the audible sound of someone trying to get this over with.

The counterintuitive craft is that pauses are a gift to the viewer. A beat of silence after a point is where the point lands. A breath before a new section tells the audience the gears are changing. On playback, pauses that felt endless in the room read as confidence — the speaker who pauses looks like they know the silence won't hurt them.

Real speech also varies its speed constantly: quick through the setup, slow into the thing that matters. That variation is most of what "engaging delivery" means at the mechanical level. If you read from a prompter, this is exactly where the tool choice bites — a fixed-speed scroll penalises every pause and every slow-down, which is why prompted reads so often sound metronomic. A prompter that follows your voice makes the pause free: stop, and the script waits.

Practical drill: mark two or three deliberate pause points in your script or notes — after the key claim, before the turn — and honour them on the take. Externalising the decision beats trying to feel your way to it under nerves.

Hands, posture, and the rest of you

The question "what do I do with my hands" has a short answer: what you do in conversation, which is gesture. Hands visible and moving naturally read as engaged; hands pinned to your sides read as a hostage video. If you gesture when you talk to friends — most people do — let it happen in frame.

Posture does quiet work. Sitting or standing tall, shoulders open, a slight lean toward the camera: together they read as interest in the viewer. A collapsed posture reads as low energy before you've said a word, and it genuinely constrains your breathing and therefore your voice.

And movement is allowed. Shifting weight, turning slightly, leaning in for the important line — small motion reads as alive. The frozen head-and-shoulders lock that nervous speakers adopt is the thing that looks strange, not the moving.

The warm-up, and why take one is a rehearsal

Voices and faces need a minute to arrive. The first read of any session is reliably the stiffest — most careful, most formal, least you — and the expensive mistake is spending it on the take that counts.

A two-minute warm-up before recording: say your first paragraph out loud, at full performance volume, off camera. Roll your shoulders. Say something ridiculous at volume to loosen the voice. Then treat the first recorded take as a rehearsal by design — press record, do the whole thing, and expect to use the second one. Sometimes the rehearsal take turns out to be the keeper, which is a pleasant surprise rather than a plan.

If nerves are the bigger obstacle — if the problem isn't technique but the feeling in your chest when the red light comes on — that deserves its own treatment, and it has one: nervous on camera? how to record anyway.

The playback habit

The single practice that improves on-camera speaking fastest is also the one people most avoid: watch your own footage. Not to cringe — to calibrate. Once a week, watch one take and ask three questions only: where did my eyes go, where did I rush, what did my energy look like from out here? Fix one thing per week.

Everyone dislikes their own recorded voice at first; it's a known artefact of hearing yourself without the resonance of your own skull, and it fades with exposure. What's on the other side of the discomfort is the thing every good on-camera speaker has: an accurate picture of what the viewer actually receives — one person, talking to them, like it's a conversation. Which is what it was always supposed to be.

This piece is practical, not motivational: what the fear actually is, why the retake sits at the centre of it, and the specific working habits that let you record anyway — which is, in the end, the only thing that makes the feeling smaller.

What the fear actually is

Camera shyness is rarely about the camera. The lens is a small glass circle; it has no opinions. What it represents is the uncomfortable trio of being seen, being recorded, and being judgeable later — a conversation where the other party is everyone, forever, with a rewind button.

And for most people the sharpest edge is not the audience at all. It's the retake. The moment you stumble, stop, and have to start again — with the fresh knowledge that you just failed at talking, a thing you do effortlessly all day. Each abandoned take confirms the story ("I'm bad at this"), which tightens the next attempt, which produces the next stumble. The spiral is the problem, far more than any individual flub.

Which is good news, in a practical sense: you can't argue a feeling out of existence, but you can absolutely dismantle a spiral. Every technique below is a way of making a single stumble cost less, so the story never gets its evidence.

Nobody sees take one

Start with the structural comfort, because it's real: recording yourself, alone, is the lowest-stakes version of public speaking that has ever existed.

There is no live audience. There is no moment of failure witnessed by anyone. Take one can be terrible — take one is allowed to be terrible — and the only person who will ever know is you, in the edit, with a delete key. A presentation to a room happens once; a recording happens as many times as you like and the world sees only the version you chose.

Say the implication plainly to yourself before a session: nothing that happens in this room today is public. It sounds obvious. Nerves are not good at obvious things, which is why it's worth saying.

Preparation is nerve reduction

Most on-camera nerves are, underneath, uncertainty — about the words, the kit, whether it'll fit, whether you'll dry up. Every piece of uncertainty you remove beforehand is a piece the nerves can't use.

A script you trust. Dread of drying up disappears when the words exist and are within sight. Write the script in your speaking voice, read it aloud once before the session, and fix every phrase you trip on — a script your mouth has already handled once is a script that won't ambush you.

Know that it fits. If part of the worry is "this is meant to be three minutes and I have no idea", measure it: a read-time based on your actual pace, or one timed rehearsal pass, converts "I hope" into "I know". Certainty is calming in direct proportion to how specific it is.

Rehearse once — then stop. One full read-aloud takes the newness off. Beyond one or two, rehearsal turns into memorisation, and half-memorised scripts produce their own anxious cadence — the sound of someone checking themselves. Trust the script to be there; that's its job.

Make the kit boring. Camera charged, framing checked, prompter mirrored and sized, one sentence read as a sound check. A settled rig is one less live variable, and nerves feed on live variables.

Making the stumble cheap

Here is where setup choices quietly do emotional work.

A stumble is a marker, not a restart. In ordinary conversation you fluff words constantly and repair them without noticing. On camera, the same fluff feels like a failed take only if your system treats it as one. It doesn't have to: note where it happened, keep going, and re-record that sentence later if it even needs it. If you use TellyPrompter, saying "Telly, marker" drops a note at the stumble while the take keeps rolling — the stumble becomes an entry on a list instead of a verdict on the take. Small takes with small flubs left in also tend to read as human rather than sloppy.

The script should follow you, not the reverse. A prompter scrolling at a fixed speed adds a second fear to the pile: fall behind and the text abandons you. A prompter that follows your voice removes it — pause to breathe and the script waits, stumble and backtrack and it comes back with you. For a nervous reader this is the difference between a script as rails and a script as a safety net.

Cap the takes, out loud. Decide before you start: two takes, at most three, then move on. Open-ended retaking is the spiral's natural habitat — take six is where self-consciousness compounds and you start performing "not messing up" instead of the script. A cap converts the session from a test you can fail into a procedure you complete.

Two clean-enough beats one perfect. Record the piece twice and choose later. Reframing it as a selection problem takes the weight off every individual run — neither take has to be the take.

Spend the nerves once

Nerves are worst at the top of a session and fade as you go — the first take of the day is reliably the tensest, and by the third video you're mostly just working. That's an argument for batching: script several videos, set the rig up once, and record them in one sitting, so the day's ration of dread gets spent on one warm-up rather than freshly every week. Put a throwaway warm-up read first and the hardest script second, while your settled energy is at its peak. The full working system is in the batch recording guide.

Between takes, small physical resets help more than pep talks: stand up, roll your shoulders, one slow breath out longer than the breath in, sip of water. The body carries the tension; give it something to do with it.

Confidence is a result, not a requirement

The last reframe is the one that matters most. You do not need to feel confident to press record. Confidence on camera is what accumulates from having recorded — each finished session files a quiet piece of evidence against the story, and the feeling follows the evidence, usually some weeks behind it.

So the goal for any single session is not "feel good". It's smaller and entirely achievable: finish, with the stakes held low. Script trusted, takes capped, stumbles marked rather than mourned, nothing public until you say so. Do that a handful of times and you'll notice the dread arriving later and leaving earlier — and somewhere after that, you'll notice you're mostly thinking about the video, not about yourself, which is what confidence actually feels like from the inside.

For the craft side of what to do once the nerves have loosened their grip — eyes, energy, pacing — carry on to how to talk on camera. And if recording ever feels genuinely unmanageable rather than uncomfortable, talking it through with someone you trust is a strength, not a failure of technique.

Why captions are worth the bother

Two audiences read your captions, and both are larger than most creators assume.

The first watches with the sound off — on phones, in public, in feeds where video autoplays muted and the first seconds decide everything. For them, captions aren't an accessibility extra; they're the only version of your words that exists.

The second relies on captions to follow speech at all: deaf and hard-of-hearing viewers, people watching in a second language, anyone in a loud room. For them, caption accuracy is the difference between being included and being guessed at.

Platforms will happily auto-generate captions, and auto-captions are far better than nothing. But they're transcription — and for scripted video specifically, transcription is solving your problem backwards.

SRT and VTT in plain terms

A caption file is simpler than its reputation. The two formats you'll meet:

SRT is the old workhorse: numbered blocks of text, each with a start and end time. Nearly everything accepts it — YouTube, editing software, most platforms.

VTT (WebVTT) is the web-native sibling: much the same idea with more styling and positioning options, and the format HTML5 video players speak natively. If you embed video on your own site, VTT is the one you want.

Both are plain text with timestamps. The entire job of captioning is producing two things accurately: the words, and the times at which they're spoken. Keep those two halves in mind, because they're where the two approaches differ.

Where transcription goes wrong on scripted delivery

Automatic transcription listens to your audio and infers the words statistically. On casual, improvised speech it's the only option and does a fair job. On scripted delivery, it has a structural absurdity to it: the exact words already exist, in a file, written by you — and the transcriber ignores that file and guesses from sound.

The guesses fail in predictable places:

Proper nouns and product names. Your name, your channel's name, the tool you're reviewing, the town you're in — precisely the words that matter most in your video are the words a general speech model has seen least. They come back mangled, differently each time.

Technical and niche vocabulary. Every field's jargon is a transcription minefield, and a channel is nearly always in some field.

Homophones resolved by guesswork. The model picks whichever spelling is statistically likelier, which is not always the one you wrote.

Your stumbles, faithfully preserved. Transcription captures what you said, including the false start you'd rather captions smoothed over.

The result is a familiar workflow: generate auto-captions, then spend twenty minutes per video re-reading them line by line, fixing the mistakes — a proofreading pass against your own script, done by eye. The words you're correcting them to were on your screen the whole time.

The other half: timing

Suppose you skip transcription and use the script directly — paste it into a caption tool. Now the words are perfect, but the times are missing: nothing knows when each line was actually said in the take. Manual syncing means dragging caption blocks along a waveform, and it's tedious enough that most people give up and go back to fixing auto-captions.

So the real requirement for script-accurate captions is both halves at once: the script's exact words, and per-line timing from the actual take. Which is where the teleprompter, of all things, turns out to hold the answer.

Captions from the prompter: script plus timing, no guessing

A voice-following teleprompter works by matching your speech against the script as you read — that's how the highlight stays on the word you're saying, through pauses, ad-libs and backtracking. (The full comparison of scroll modes is in voice-following vs constant scroll.)

Notice what that matching produces as a by-product: the prompter knows when you said each word of the script. Not inferred afterwards from audio — observed live, during the take, word by word.

TellyPrompter keeps that per-word timing for each take and exports it as SRT or VTT. The result is captions with the script's exact words — every proper noun, every technical term, spelled the way you wrote them — timed to your actual delivery, including the pause you took before the important line. No transcription pass, no proofreading your own words back into shape. The caption file is the script, as read, with the take's real clock attached.

On a batch day this compounds: export captions per take while everything's fresh, and the edit inherits accurate caption files alongside the footage. The take itself is hands-free too — recording starts with the mic, and "Telly, stop" and its siblings run the session from your mark — so the timing data accumulates without any extra step. It's simply what following your voice produces.

The honest scope

Worth stating plainly, because a captioning claim should be exact about what it covers.

The export captions the script as read. If you follow the script — with normal pauses, emphasis and small variations — the captions are your words at your times. If you skip a section mid-take, the matching follows you, and the captions reflect the read.

Heavy ad-libbing is the transcription case. Words you improvise aren't in the script, so no script-based export can caption them — a long unscripted aside needs a transcription pass for that stretch, or a quick manual addition. Script-accurate captioning is for scripted delivery; that's the honest boundary of the idea.

The timing depends on the following. Voice-following is built on the browser's speech recognition, so its quality varies by platform, language and microphone — and Firefox doesn't implement the Web Speech API at all, so there's no voice-following there to produce timing. Where the following is solid, the timing is; the practical test, as ever, is reading a real script aloud and looking at what comes out.

Captions still deserve a skim. Not the line-by-line rescue that auto-captions need — just the once-over anything public deserves.

A workflow worth stealing

For a scripted talking-head video, the captioning step can shrink to almost nothing:

1. Write the script for the mouth, and read it once aloud before recording.
2. Record with voice-following on — the timing accrues as you read.
3. After the keeper take, export SRT for the platform, VTT if you embed on your own site.
4. Skim the file once. Upload it alongside the video rather than relying on auto-captions.

The larger point hiding in this piece is about where accuracy comes from. Transcription works backwards from sound to words and is impressive for what it is. But when the words already exist — when you wrote them, rehearsed them and read them — the accurate caption source was never the audio. It was the script, waiting to be given the take's timing. A prompter that follows your voice is, quietly, the tool that does exactly that.

What memorising actually costs

Memorisation has a romance to it — the speaker with no notes, fully present — and for certain jobs it earns the romance. But the costs are real and worth pricing before you commit an afternoon to them.

Time, first. Reliably memorising even a three-minute script — around 400 to 500 words — takes most people multiple sessions across a day or more, and the time scales badly: a ten-minute video is not three times the effort, it's more, because long material interferes with itself. For a weekly channel, memorisation as the default workflow is a part-time job.

Fragility, second. A memorised script has a specific failure mode: the blank. Mid-take, mid-sentence, the next line simply isn't there — and unlike a conversational stumble, a memory blank has nothing to grab. The take dies, and so does a little confidence with it.

And the trap nobody warns you about: recited recall sounds worse than reading. The point of memorising is naturalness, but imperfectly memorised material produces the least natural delivery there is — the upward-glancing, evenly-paced cadence of someone reading an internal autocue. Attention that should be on meaning is spent on retrieval, and audiences hear retrieval. A speaker confidently reading well-written lines from a well-placed prompter routinely sounds more natural than a speaker straining to remember the same lines.

How to memorise, if the job calls for it

When memorisation is the right tool, do it properly rather than by brute rereading:

Chunk it. Break the script into beats of a few sentences, each with a one-word handle. Memorise the sequence of handles first — the argument's skeleton — then the words within each beat. Most blanks are structural (what comes next?), not verbal, and the skeleton prevents them.

Space the practice. Three ten-minute sessions across a day beat one hour-long grind, by a wide margin. Memory consolidates between sessions, not during them. Sleep on it once before you trust it.

Practise recall, not rereading. Rereading a script feels like learning and mostly isn't. Cover the page and attempt the beat from the handle; struggle briefly; check. The struggle is the learning.

Say it aloud, on your feet, ideally where you'll perform. Silent memorisation stores the wrong version — the mouth, breath and body are part of the memory you'll need on camera.

Overlearn the first thirty seconds. Nerves hit hardest at the top; an opening you could deliver asleep buys composure for everything after it.

What the teleprompter actually costs

The prompter's trade is the mirror image: the words are guaranteed, and the risk moves to how they come out.

The classic failure is the reading voice — the flattened, metronomic cadence audiences clock instantly. It has two causes worth separating. One is script quality: text written for the page rather than the mouth resists natural delivery no matter what displays it. The other is mechanical, and it's the conventional prompter's fault: a constant-speed scroll makes you perform to a number you guessed before the take. Pause and the text sails on; breathe and you fall behind; the divided attention — half speaking, half tracking a moving surface — is precisely what sounds wooden.

Both causes have fixes. Write the script in your speaking voice and read it aloud once before recording; and place the script over or beside the lens so your eyes stay still. The craft is learnable in an afternoon, and how to read a teleprompter without sounding wooden covers it end to end. The mechanical cause has a sharper fix, which is the third way below.

What the prompter buys, in exchange: zero preparation time per video beyond writing (which you were doing anyway); exact wording where wording matters — claims, disclosures, sponsor language, anything you can't afford to paraphrase; and length without fear, because minute twelve is as safe as minute one. For a creator publishing weekly, these are not small things; they're the difference between a sustainable pipeline and a heroic one.

The third way: a script that follows you

The memorise-or-prompt debate quietly assumes the prompter is a conveyor belt — that reading means keeping up. A voice-following prompter breaks the assumption: it listens as you read and keeps a highlight on the word you're actually saying, through pauses, ad-libs, skipped lines and backtracking. The scroll has no speed of its own; your read is the speed.

That changes the choice, because it captures a large share of what memorisation was buying:

Freedom to pause and vary pace — the expressive range that a fixed scroll punishes — is free, because the script waits.

Freedom to leave the script — the aside, the plainer restatement, the joke that occurs to you — is free too: wander off, and when a scripted phrase comes back out of your mouth, the highlight picks you up where you resumed.

And the script becomes what notes are to a confident speaker: a floor, not a track. You perform from partial familiarity — the one read-aloud pass you did anyway — knowing the exact words are there the instant you want them. No blank is possible, because nothing depends on recall.

In practice this lands closest to how experienced speakers actually work: mostly present, occasionally checking, never stranded. Speech recognition runs on the device and the audio is never uploaded. The honest limits: recognition quality is the browser's, varying by platform and language, and Firefox doesn't implement the Web Speech API — there, constant and sound-level modes still scroll, and the trade-offs revert to the conventional ones.

Choosing, job by job

Memorise when the piece is short and will be performed repeatedly — a talk you'll give ten times, a pitch, a toast; when the camera must move with you and no script placement survives the blocking; or when the material is so personal that any mediation would show.

Prompt when the material is long, dense, or precise; when you publish on a schedule and preparation time is the scarce resource; when it's recorded once and the retake is cheap; or when exact wording is a requirement rather than a preference.

Use voice-following when you want a prompted read that behaves like a delivered one — for a solo creator recording talking-head video, that's the default case, not the exception. It's also the honest answer to the hybrid instinct many people land on ("memorise the gist, keep the script nearby"): that's exactly the workflow it mechanises, minus the memorising.

One last reframe, because the debate is often really about self-image: using a prompter is not cheating, any more than a musician's sheet music is cheating. The audience never experiences your preparation method — they experience the delivery. Choose the tool that gives them the best version of you talking, and spend the hours you saved on the thing no tool prepares: being worth listening to on camera.

This piece covers what "supports your language" should actually mean in a teleprompter, why right-to-left is harder than it looks (especially on a mirror rig), where voice-following stands across languages honestly, and why the typeface question belongs in the same conversation.

What language support should mean

A prompter's language support is often a checkbox that means "the text renders". For a tool you perform from, the bar is higher, because four separate things have to be true:

The script displays correctly — including non-Latin alphabets, connected scripts like Arabic where letters change shape by position, and the diacritics many languages depend on.

The direction is right — not just per-line, but as a reading experience: where new text arrives from, which edge the eye returns to.

The reading aids work in your language — sentence-end markers, the position highlight, the line the eye rests on. A highlight that only understands full stops fails everywhere punctuation differs.

And ideally, the following works — the voice-tracking that keeps your place, in your language, not just in English.

TellyPrompter handles 34 languages across that whole stack. When you paste a script, automatic detection identifies the language and sets sensible defaults — direction included — and an explicit language choice always wins over the detection, for the cases where you know better than the statistics.

Right-to-left, done properly

Arabic, Hebrew, Persian, Urdu: hundreds of millions of people read right-to-left, and RTL is where retrofitted prompters show their seams. Text alignment is the easy part. The harder parts:

Layout mirrors as a whole. In an RTL reading experience, the eye's home edge is the right, progress runs leftward, and the interface around the script should agree with the text rather than fight it. TellyPrompter has full RTL support across those 34 languages, non-Latin scripts included — the direction is a first-class property of the script surface, not a text-align property bolted on.

Mixed-direction text is normal, not an edge case. Real scripts mix directions constantly — an Arabic script quoting an English product name, a Hebrew script with a number and a URL. This is exactly why automatic detection alone isn't enough and the app gives you an explicit direction control: for genuinely mixed material, you decide the base direction, and the embedded runs sit inside it.

And then the mirror rig flips everything again. Here's the compound case retrofits never survive: a beam-splitter reflects the whole screen horizontally, so an RTL script on prompter glass is a right-to-left text inside a left-right-flipped display. Because mirroring and direction are both first-class in TellyPrompter, the combination just works — mirror mode flips the surface, the script keeps its correct reading direction in the glass, and nothing in the app depends on left or right meaning anything, precisely because mirrored rigs are normal use.

Voice-following across languages, honestly

The voice-follow — the highlight that tracks the word you're speaking, through pauses, ad-libs and backtracking — works in any of the 34 languages the browser's speech recognition supports. Read in Spanish, the script follows in Spanish; the same in Arabic, Korean or Polish.

The honest part, stated plainly: recognition quality is the browser's, not ours, and it varies by language, platform and microphone. The engines behind the Web Speech API are trained more heavily on some languages than others; a language the engine handles well gives you following as solid as English, a language it handles poorly gives you looser tracking. This cannot be tuned from the app's side, and any prompter claiming otherwise about browser-based recognition is overclaiming.

Three things keep this from being a gamble:

The test is two minutes. Paste a real script in your language and read a paragraph aloud. The highlight either holds or it doesn't — you'll know before the first take, not during it.

Auto voice settings resolve sensibly. Untouched, the voice preference switches on for English and stays off elsewhere with a plain explanation; your explicit on/off choice wins in every language, so a well-supported language is one toggle away.

And the other two modes are language-blind. Constant-speed scrolling and sound-level scrolling work identically in every language, every script, every direction — they don't interpret words at all. Whatever recognition thinks of your language, you have a working prompter; the product degrades, it doesn't block. One browser-level note: Firefox doesn't implement the Web Speech API in any language, so voice-following isn't available there — the other modes are.

Where the following does hold, everything built on it comes along: pauses free, ad-libs free, and voice control of the take itself.

The typeface is part of language support

Reading aloud under pressure is its own skill, and for a lot of people — dyslexic readers prominently among them — the typeface decides whether a script is performable at all.

TellyPrompter ships OpenDyslexic as a first-class script face: same size range, same reading states, same treatment as the default face, not an accessibility toggle tucked in a corner. For readers who find standard faces swim under pressure, that's simply the difference between a script they can perform from and one they can't.

Two related choices run through the whole app, and they matter more on a rig than anywhere else. No cue is carried by colour alone — roughly one man in twelve can't reliably resolve a colour-only distinction, and the position highlight is the single most load-bearing element on the screen, so it never depends on colour to be findable. And contrast is set assuming beam-splitter glass has already eaten a third to a half of the light, so the critical cues survive the rig, whatever script they're written in.

Setting up in your language: the two-minute pass

1. Paste your script. Detection sets the language and direction; override either explicitly if the material is mixed or the detection guessed wrong.
2. Pick the face — the default or OpenDyslexic — and size it from where you'll actually stand, not from the desk.
3. On a mirror rig: mirror mode on, then confirm with a real sentence in the glass that the script reads correctly in its own direction.
4. Read one paragraph aloud. If the highlight holds, voice-follow is available in your language; if it's loose, switch to sound-level or constant and the session proceeds identically.
5. Take the take.

The larger point is the quiet one. A creator recording in Arabic or Hindi or Hebrew shouldn't need an English-first tool's grudging accommodation — the reading experience, the rig behaviour and the honesty about recognition should all be built as if their language were the first one considered. That's a page most of the category can't write truthfully, which is exactly why it was worth building. For where the prompter fits in the wider recording setup, start with the YouTube setup guide; for the craft of the read itself, how to read a teleprompter without sounding wooden applies in every language here.

This piece explains why hands-free matters more on a prompter than almost any other tool, what the voice commands actually do, where a physical remote still wins honestly, and how the pieces add up to a take you never touch.

Why a prompter has to be hands-free

Picture the situation the tool actually lives in. A take is running. Your hands are in frame — gesturing, holding a product, resting naturally. Your eyes are on the lens. The phone is on a rig at your mark, possibly sealed behind beam-splitter glass, and walking over to poke it means breaking the shot, the framing and your own settle.

Mid-take, the prompter is effectively untouchable. Which is why the design assumption has to be that it cannot be looked at or touched while it matters — anything that needs a tap during a performance is a feature that belongs on the setup screen instead.

The traditional patch is hardware: a Bluetooth clicker to nudge the scroll, a foot pedal to pause it. These work, and for some setups they remain the right call — more on that below. But they treat the symptom. Most of what a solo creator needs mid-take isn't scroll adjustment at all; it's take control — start, stop, again, note that stumble — and that's a job speech does better than thumbs.

The scroll that needs no controlling

Start with the reason the usual remote exists, because voice-following removes most of it at the root.

On a constant-speed prompter, the scroll is a guess you made before the take, and the remote is how you correct the guess live — nudge it faster, pause it for a breath. The remote is compensation for a scroll that doesn't know where you are.

A voice-following prompter knows where you are: it listens as you read and keeps the highlight on the word you're saying, through pauses, ad-libs, skipped lines and backtracking. There's no speed to correct, so the single biggest job of a prompter remote simply evaporates. Pause, and the script waits — no pedal required. The full comparison of scroll modes covers this properly; the short version is that the best remote control for scrolling is a scroll that follows you.

What's left is controlling the take — and that's where the commands come in.

The take, run by voice

One press starts everything. In TellyPrompter, the mic button is the take: recording starts and the script starts following you, one decision, one press — made before your hands are in frame, so it doesn't need a command. Arming the camera is separate, decided between takes; rolling is decided at the top of one.

From your mark, the session then runs on a small vocabulary, each command prefixed with the wake word so ordinary script text never triggers anything:

"Telly, stop" ends the take — recording written, done, from wherever you're standing. Ending a take writes the file; so does disarming the camera or leaving for the library, because a perfect performance should never end with no file.

"Telly, again" starts the retake. No walk to the rig, no re-settle, no gap for the doubt to creep into — the fluffed take ends and the fresh one begins from your mark. On a batch day this single command is most of the tempo.

"Telly, marker" drops a marker at that moment and the take keeps rolling. This is the quiet workhorse: a stumble mid-take stops being a decision ("restart? push on? will I remember where that was?") and becomes an entry on a list. Afterwards, the post-take stumble report shows exactly where the rough spots were — so "was that take clean?" is answered at a glance rather than by scrubbing back through footage.

"Go back" and "go next" handle navigation, and tapping any word jumps the script to it between takes.

The wake word is deliberate friction: "stop" appears in scripts constantly, so the bare word does nothing — the command is exact, and a script that happens to contain the phrase is checked against, not obeyed.

Where a physical remote honestly wins

A voice-controlled prompter has real edges, and pretending otherwise would undo the point of this piece.

Constant mode still benefits from hardware. If you deliberately run a fixed-speed scroll — rehearsed pace, timed material — the speed-nudging job returns, and that's a genuine clicker-or-pedal job. Voice commands control takes; they aren't a speed dial.

Firefox has no voice at all. Firefox doesn't implement the Web Speech API, so neither voice-following nor voice commands exist there — the prompter itself still works, on constant and sound-level modes, and there a remote earns its place traditionally.

Recognition is the browser's. Command recognition rides the same engine as the following, so its reliability varies by platform, language and microphone, and a very loud room degrades it. The practical test is the usual one: say the commands once during setup and watch them land.

And some rooms need silence. If you're recording in a context where a spoken "Telly, stop" would sit awkwardly at the end of every take — it's easily trimmed, but it exists in the raw audio — a hardware stop, or simply ending from the device between takes, may suit you better.

None of these are reasons to buy a remote first. They're the honest boundary of not needing one.

What it adds up to

Put the pieces together and the whole session runs from your mark: press the mic, perform, mark the stumbles as they happen, say "again" until it's right, say "stop", and the file is written with a stumble report and per-take timing attached — timing that also gives you script-accurate captions as a by-product, no extra step.

There's a cost comparison buried in here, but it isn't really about the price of a clicker. It's about moving parts. A remote is one more battery, one more pairing, one more thing in your hand that isn't a gesture. A prompter that follows your voice and answers to it needs nothing in your hands at all — which, on a tool whose entire job is to let you talk to a lens like a person, is how it should have worked from the start.

Speech recognition runs on the device and the audio is never uploaded.

A note on method before we start: the facts below about other products come from their own published pages and store listings, checked in August 2026. Features and prices change, so treat the specifics as a snapshot and check the vendors' own pages before deciding. And a disclosure in the other direction: TellyPrompter is ours, so read our entries with that in mind — we've tried to hold every product, including our own, to the same standard of only saying what's verifiable.

The four questions that actually decide it

How does the scroll work? This is the deepest difference between prompters. Most scroll at a constant speed you set beforehand; a smaller group can follow your voice, matching your speech against the script so pauses, ad-libs and backtracking don't cost you your place. If you're not sure which you want, the full comparison of scroll modes is the place to settle it — the short version is that voice-following is the mode that makes a solo read sound like talking.

What does free actually include? Free tiers differ enormously: some are complete products, some are trials with a watermark, some gate the headline feature. The thing to check is whether the specific capability you came for — usually the scroll mode, the recording, or both — is in the tier you'd actually use.

Where does it run? Native apps offer deep platform integration; browser-based tools run anywhere without an install. Which matters depends on your rig — a prompter that runs in any browser will run on the old tablet in your hood.

Where does recognition happen? Any prompter that listens raises the question of where the audio goes. Architectures genuinely differ — some process speech on the device, some send it to a server — and for unreleased or client material it's a question worth asking of any product, ours included.

Teleprompter.com

The category incumbent, with native apps for iOS and Android plus Mac and web versions, and the broadest ecosystem in the category: cloud-stored scripts, subtitle generation, and an unusually wide range of remote controls — Apple Watch, keyboards, foot pedals, even game controllers. Its published plans start with a free Starter tier that records with a watermark at 1080p, with paid tiers (from $7.50 a month billed yearly, per its pricing page) adding 4K recording, watermark removal and the rest; voice-activated scrolling appears among its plan features alongside fixed-speed and timed modes.

Where it wins: platform coverage and the surrounding toolset. If you want one subscription across phone, desktop and web with 4K recording and hardware remote support, this is the mature option.

What to check for your case: which scroll mode and export quality sit in which tier, since the free tier's watermark and resolution limits are part of the design.

PromptSmart

The voice-following pioneer among native apps. Its patented VoiceTrack scrolls the script by speech recognition — it follows your pace and, if you go off-script, holds your place until you return — and by the developer's own description the recognition runs on the device and works without an internet connection, which is the right architecture for the job and worth crediting plainly. Native apps for iOS and Android, in-app HD recording, and imports for DOCX, PDF, RTF, TXT and Google Docs. VoiceTrack sits behind the paid subscription in the current PromptSmart+ model, with a free trial tier.

Where it wins: a proven, patented voice-follow inside a native app. If you specifically want speech-tracked scrolling with the feel and integration of a platform app rather than a browser, this is the established choice.

What to check for your case: the language coverage of the tracking for your language, and which features sit behind the subscription — the store listings are explicit about both.

SpeakFlow

The browser-based option built around teams. It runs in any browser with no install, its Flow mode scrolls by voice, and its distinctive strengths are collaborative: shared workspaces, real-time script co-editing, remote control of the prompter from a second device, and an overlay mode designed for reading during live calls while holding eye contact. In-browser recording is included, with a free plan and paid plans from $15 a month billed yearly per its published pricing.

Where it wins: teamwork and live-call use. If scripts pass between writers and presenters, or a producer needs to drive the prompter from another device, SpeakFlow is built for exactly that shape of work.

What to check for your case: it's a cloud product by design — scripts live in its workspace and it expects a connection — which is the right trade for collaboration and worth being deliberate about for solo offline work.

TellyPrompter

Ours, so hold it to the same four questions.

The scroll: voice-following is the founding feature — the highlight tracks the word you're speaking, through pauses, ad-libs, skipped lines and backtracking, with constant and sound-level modes alongside. The free tier: deliberately complete — all three scroll modes, 34 languages with full right-to-left support, mirror mode, the script library with tags, and in-app recording without a watermark — with no account anywhere on the path from pasting a script to running one. The paid tier adds a synced unlimited cloud library across devices; how the free tier is designed covers the tier thinking in full. Where it runs: the browser — any device with one, no install, and as an installable PWA it works offline after the first visit. Where recognition happens: speech recognition runs on the device and the audio is never uploaded.

Where it honestly doesn't win: there are no native apps — if you want App Store integration, platform widgets or an Apple Watch remote, the incumbents above have it and we don't. Voice features depend on the browser's speech recognition, so quality varies by platform and language, and Firefox doesn't implement the Web Speech API at all — there you get a working prompter on the other two modes, not the voice-follow. And it's early: the products above have years of ecosystem around them that a newer tool simply hasn't had time to grow.

Choosing, by situation

You want one app across every device with 4K recording and hardware remotes: Teleprompter.com — the ecosystem is the product, and it's a mature one.

You want voice-following inside a native mobile app: PromptSmart — the patented on-device VoiceTrack is the category's longest-standing implementation.

Your scripts are a team sport, or you read during live calls: SpeakFlow — collaboration and overlay mode are its home ground.

You record yourself to camera and want voice-following, free, in the browser, with recognition staying on the device: that's the case TellyPrompter was built for — solo creators, often on a mirror rig, who want the script to follow the read and nothing standing between pasting and performing.

The genuinely good news about this category is that trying costs nothing: every product here has a free tier or trial, and a teleprompter reveals itself in one honest test — paste a real script, read a paragraph aloud at performance pace with one deliberate pause and one ad-lib, and watch what the scroll does. The app that kept your place, on the device you'll actually rig, is your answer, whichever name is on it.

If you make videos about this category — rig setups, app comparisons, creator tooling — our affiliate programme may be worth a look.

It is the default format of solo creation for a reason. It costs almost nothing to make, it builds trust faster than any other format because the viewer can see your face while you make your claims, and it is how most channels find their voice. It is also the most exposed format there is. A tutorial can cut away to a screen recording and a vlog can cut away to the world; a talking head has nowhere to go, so every weakness in the setup and every wobble in the delivery stays on screen for the whole video.

The encouraging part: all four of the things that decide it are fixable in an afternoon, and only one of them might cost money.

Why the format works, and why it is unforgiving

A talking head video is one half of a conversation. The viewer is cast as the person you are talking to, and everything that makes conversation feel real — eye contact, natural rhythm, the sense that the words are being said rather than recited — is what makes the video work. Everything that breaks the illusion breaks the video: eyes that keep flicking away, a voice with the flat evenness of reading, light that makes you look like you are somewhere strange.

Which means the job is not "look professional". Broadcast polish is optional and plenty of well-loved channels do without it. The job is "seem present", and that is a lower bar for kit and a higher bar for delivery than most beginners expect.

Framing and eye line: the geometry of being talked to

Put the camera at eye level. Below eye level looks down on the viewer; above it makes you look up like you are being interviewed. Eye level reads as equal, which is the register of conversation.

Then think about distance. Framing from roughly mid-chest up, with a little room above your head, is a comfortable conversational distance — close enough to read your face, far enough not to loom. But there is a second reason to move the camera back and crop in, and it matters more than the framing itself: eye line.

If you are reading a script, the giveaway is the eyes. The closer your words sit to the lens and the further away you stand, the smaller your eye movement — at two or three metres, a script beside the lens reads as eye contact; at arm's length, it does not. This is geometry rather than acting ability, and it is worth getting right before you work on anything else, because a wandering eye line undoes every other improvement. We have a full guide to eye contact and script placement, and if you want the words directly on the lens axis, that is what beam-splitter rigs are for.

Light: one window beats most kit

The single free upgrade is to face a window. Soft daylight on your face, camera between you and the window, and you are ahead of most purchased lighting setups. Avoid a window behind you — cameras expose for the bright background and turn you into a silhouette — and avoid overhead room light on its own, which shadows your eyes.

One detail specific to reading from a screen: the screen is a light source pointed at your face. A bright white script at close range casts a glow onto you and reflects in glasses. A dark background with light text solves most of it, and it is another quiet argument for more distance between you and whatever you are reading from.

If you do buy anything, one soft light placed just off the camera, slightly above your eye line, is the whole shopping list for this format.

Sound: closer than feels polite

Viewers forgive soft picture far more readily than rough audio, and the biggest audio improvement is not a better microphone — it is a closer one. Whatever you record on, halving the distance to your mouth does more than doubling the price of the kit. A lapel mic, a phone just out of frame, even wired earbuds all work if they are near you; the expensive microphone across the room does not.

The other half is the room. Echo is the sound of bare walls and hard floors, and it reads as amateur even when nothing else does. Curtains, a rug, a sofa, recording in the furnished corner rather than the empty one — soft things in the room matter more than anything on the microphone's spec sheet.

The read: where good setups still fall down

Here is the pattern behind most talking head videos that are almost good: the framing is right, the light is fine, the sound is close — and the delivery is flat, because the person is reading, and you can hear it.

The usual culprit is not a lack of performing talent. It is that a conventional teleprompter asks you to guess a scroll speed before you start and then perform to it, so half your attention spends the take tracking a moving target instead of talking. That divided attention is the flatness. The fix is partly craft — we have written a full guide to reading naturally — and partly a setup decision. TellyPrompter follows your voice instead: the highlight tracks the word you are actually saying, through pauses, ad-libs and backtracking, so the pace of the take is set by your delivery rather than a number you guessed. Speech recognition runs on the device and the audio is never uploaded. One honest limit: voice-following depends on the browser's speech recognition, which Firefox does not provide — the constant and sound-level modes still work there.

However you scroll, write the script the way you speak. Contractions, short sentences, line breaks where you would breathe, and one read-aloud pass to fix every phrase your mouth trips on. A script in your speaking voice is half the delivery done before you press record.

Keep the take human

Perfection is the wrong target for this format, because conversation is not perfect. A small stumble left in usually reads as a person rather than a mistake. Two clean-enough takes with a choice made in the edit beat six increasingly tired attempts at a flawless one — by take eight you are performing "not messing up", which the viewer can feel.

And say something off script. The aside that occurs to you mid-take is frequently the most watchable moment in the video, because it is the one moment that could not have been written down. Give yourself a marked place to do it, and let the rest of the setup — the framing, the light, the sound, the scroll that waits for you — carry the machinery, so the whole of your attention is free for the only thing the format is actually about: talking to the person on the other side of the lens.

For the hardware side — propped phones, hoods, beam-splitters and what each is worth — see the full setup guide, and for the wider craft of being on camera, start with how to talk on camera.

This guide covers the craft half of that: where the camera goes, how to light and mic yourself with what you own, how to check you are in shot without a second pair of hands, and how to read a script when there is nobody to hold cue cards. The workflow half — batching scripts, running take after take, ending with files you can actually use — has its own guide.

Your phone is the camera, and that is fine

Start with the camera you have. A phone from the last several years shoots better video than most dedicated cameras did a decade ago, and for a talking head at conversational distance, the difference between a phone and a proper camera is far smaller than the difference between good light and bad. If you later outgrow the phone, the DSLR and mirrorless setup is a separate ladder rung; do not start there.

Two rules make phone footage look deliberate. Use the back camera if you can — it is better than the selfie camera on almost every phone — and fix the phone to something. A tripod is ideal and cheap; a shelf, a stack of books or a proper phone rig all beat holding it. Camera shake is the fastest way to make a video feel accidental.

Eye level, then distance

Set the lens at your eye level. Propped on a desk, most phones end up looking up your nose; mounted too high, you look like you are apologising. Eye level is the height of conversation and it is worth the extra minute of fiddling every single time.

Then move the camera further back than feels natural and crop in, for two reasons. The framing is more flattering at a distance — faces distort subtly when a wide lens is close. And if you are reading, distance shrinks your eye movement: words beside a lens two or three metres away read as eye contact in a way that words beside a lens at arm's length never do. The eye contact guide covers the geometry properly.

Light and sound with what you own

Face a window. Camera between you and the daylight, soft light on your face — that is the entire lighting lesson for a first setup, and it beats most bought kit. Never sit with the window behind you, and never rely on a ceiling light alone unless you enjoy eye shadows.

For sound, closeness beats quality. Any microphone near your mouth — a lapel mic, wired earbuds, a second phone recording just out of frame — outperforms a good microphone across the room. And treat the room itself: echo off bare walls reads as amateur faster than any picture problem, and a rug and a pair of curtains fix more than a new microphone would.

Checking you are in shot, alone

The classic solo problem: you frame the shot, sit down, record ten minutes, and discover you drifted half out of frame at minute two. Without an operator, you need a monitor you can see from the performing position.

The phone's screen faces the wrong way if you are using the back camera, so either use a rig with a mirror, glance at the framing before each take rather than during, or — if you are recording in TellyPrompter — use the split-screen layout, which puts your camera preview and your script on the same screen. The split between them drags, because how much you need to see of yourself against how much script you need is not something an app can decide for you; a quarter of the screen each way is the limit, and it remembers your choice.

The deeper answer is to stop checking mid-take at all. Frame it, confirm it, then trust it — a glance at a monitor every few seconds is visible in your eyes, and it costs more than the reassurance is worth.

Reading without a crew

With no one to hold cards or run a prompter, the script has to run itself. A conventional prompter makes you guess a scroll speed and then keep up with it, which means part of you spends the take operating software — exactly the divided attention a solo shoot cannot spare. TellyPrompter follows your voice instead: the highlight tracks the word you are saying, waits through pauses and ad-libs, and picks you up when you come back to the script, so there is nothing to operate once you start. Speech recognition runs on the device and the audio is never uploaded. The honest caveat: voice-following needs the browser's speech recognition, which Firefox does not provide — constant and sound-level scrolling still work there.

Whatever scrolls the script, write it the way you talk and read it aloud once before you record. Every phrase your mouth trips on in rehearsal will trip harder on camera, and fixing it costs one edit now or four takes later.

The last check before you press record

A thirty-second ritual saves most ruined takes: lens clean, phone in flight mode or notifications off, framing confirmed, a clap or a word spoken at performance volume to check the sound is actually recording, and the script loaded with the first line where your eyes will land. Then record, and let a nervous first take be exactly what it is — the warm-up nobody ever sees.

You are allowed to make this easy for yourself. Solo filming is not a lesser version of a crewed shoot; it is its own discipline, and the whole of it is preparation that lets the performance happen unattended. Get the room right once, and every video after that starts at "press record".

This is the workflow guide. The craft of solo filming — framing, light, sound, eye line — has its own article; this one is about the system around it.

Before: load the day, not the take

The costliest habit in solo recording is setting up per video: write a script, rig the camera, record, tear down, repeat next week. The setup is the expensive part, so make it pay for several videos at once. Batch recording covers the case for shooting a week in a session; the short version is that your third take of the day is better than your first, and the room is already right.

Practically, that means arriving at the shoot with every script already written and loaded. TellyPrompter's library holds them with one tag each — a "This week" tag is enough — so the gap between videos is picking the next script, not hunting for it. Two preparation tools earn their place here: the measured read-time tells you what each script actually costs in minutes before you commit the afternoon to it, and rehearsal mode lets you do the one read-aloud pass that catches the phrases your mouth refuses, while fixing them is still a text edit rather than a retake.

During: a take is one press, and your voice is the operator

Mid-take is the worst possible moment to operate anything — your eyes are on the lens, your hands are in frame, and the phone is out of reach on the rig. So the session has to run on the smallest possible set of controls.

In TellyPrompter, starting a take is one press: the mic button records and sets the script following you in the same act, because they are the same decision. Arming the camera is separate — that is decided between takes, not at the top of one. From there, the session is voice-operated. "Telly, stop" ends the take. "Telly, again" bins the attempt and rolls the next one without you leaving position — which changes the economics of the retake, because the cost of "let me just do that once more" drops to two words. And when you stumble but want to keep going, "Telly, marker" drops a stumble marker at that point in the take and moves on, so you do not have to choose mid-performance between stopping and trusting your memory.

The honest limits: voice commands and voice-following ride on the browser's speech recognition, which Firefox does not provide — everything else works there, with constant or sound-level scrolling. And recognition quality is the browser's, not ours; it varies by platform and microphone.

One habit completes the during-phase: end every take deliberately, but know that the app is defensive about your files. Ending a take, disarming the camera, and leaving for the library all write the recording — there is no path where a finished performance ends with no file.

After: the take took its own notes

The reason solo review is miserable is that the only record of what happened is your memory plus an unlabelled video file. This is where the voice-following engine quietly does its second job: because it knows which word you were on at every moment, each take carries its own timing data.

So after a session, the post-take stumble report shows you where the markers fell and where the read broke — you review the four flagged moments, not the full nine minutes. Per-take timing shows what each attempt actually ran, which settles "was take two faster?" with a number instead of a feeling. And when a take is the keeper, the same timing exports SRT or VTT captions built from your script — script-accurate, no transcription pass, no mis-heard words to correct — ready for the platforms that want caption files. There is a full guide to script-timed captions if that is the part you came for.

Export is free on every tier, for scripts as well as recordings — the way out is not a paid feature.

The shape of a good solo session

Put together, a session looks like this. The night before: scripts written for the mouth, read aloud once, loaded and tagged, read-times checked against the time you actually have. On the day: room rigged once, camera armed, then script after script — one press to roll, voice to stop, retake or mark, no touching the rig between videos beyond picking the next script. Afterwards: stumble reports to choose keepers, captions exported from the winners, and the rig left standing if you can spare the corner, because a standing rig is the difference between "I could record today" and "I would have to set everything up".

None of this makes you a crew. It makes the crew unnecessary — which was always the point of recording alone. For the wider set of hands-free controls, and for what makes the talking head format work once the workflow is solved, carry on there.

How the trick works

The glass is the product. Beam-splitter glass — sometimes sold as teleprompter glass or two-way mirror acrylic — transmits part of the light that hits it and reflects the rest. Mount it at forty-five degrees in front of your camera lens, lay a screen face-up below it, and the screen's image reflects into your eye line while the camera shoots straight through the glass at you. You read words that appear to float exactly where the lens is, which is why beam-splitter rigs solve eye contact outright rather than approximately.

Everything else in the build exists to serve that piece of glass: a frame to hold it at the right angle, a shroud of black material behind and around the lens so the camera does not photograph reflections of the room, and a platform for the screen. People have made working prompters from picture frames, foam board and a phone; the material matters far less than the geometry.

The three things that decide whether the build works

Kill the light leaks. The camera looks through the glass, so anything bright behind the glass — a window, a lamp, a pale wall — ghosts into your footage. The shroud is not optional trim; it is half the build. Matte black card or cloth, enclosing the path from lens to glass, and the ghosting disappears.

Respect what the glass costs you. Beam-splitter glass passes roughly a third to a half of the light that hits it, in both directions. Your camera loses some exposure, which it can compensate for — but your eyes lose the same fraction of the screen, which only the screen can compensate for. A build that seems fine at a desk fails at reading distance because the text is now dim, small and behind darkened glass. The answer is not a brighter build; it is bigger, bolder text than feels reasonable, and strong contrast with no subtle tonal steps carrying anything important.

Get the reflection the right way round. The mirror flips the image horizontally. Reading mirrored text is not a skill worth acquiring — the software must flip it for you, and it needs to be a proper mirror mode that flips the whole surface, not a font trick. Check this before you build, because it is the single most common reason a finished DIY prompter goes unused.

The half the build guides skip

Most DIY tutorials end at the box, as if the words will take care of themselves. But a prompter is a system: the glass gets your eyes to the right place, and the software decides whether reading there actually works.

Three things matter on the screen. Mirror mode, as above — non-negotiable. Text sized for your real reading distance, which through glass at a couple of metres is larger than any default. And the scroll itself, which is where a home build can quietly outperform bought hardware: the traditional weakness of every prompter, built or bought, is that it asks you to guess a scroll speed and then keep up with it. TellyPrompter runs in the browser on whatever screen your build holds — a phone, an old tablet, a spare monitor — with mirror mode, sizing for distance, and a scroll that follows your voice instead of a preset speed: pause, ad-lib or back up, and the highlight waits for you. Speech recognition runs on the device and the audio is never uploaded. One honest limit: voice-following relies on the browser's speech recognition, which Firefox does not provide — the constant and sound-level modes work everywhere. There is a longer piece on why following beats scrolling if you want the argument in full.

Because it is browser-based, the screen in your build needs nothing installed — open the site, load the script, set mirror mode, and the oldest tablet in the drawer becomes the display. That is also the cheapest possible test of whether the whole idea suits you: prop a phone beside your lens and try reading this way before you cut any board.

Build it, or buy the glass in a box?

An honest closing note. The DIY route wins on cost, on fitting odd cameras and odd spaces, and on the understanding you gain. Bought rigs win on rigidity, on optical-grade glass with fewer double-image artefacts, and on your evening. If your build wobbles every time you touch the focus ring, or the glass shows a faint second image of every word, those are the two things the commercial versions are actually charging for — and there is no shame in building the prototype and buying the tool. The full setup roundup covers the bought options honestly, and the beam-splitter setup guide applies to your build exactly as it does to a purchased rig, because from the software's point of view they are the same machine.

A note on scope before anything else: this is a setup for recorded video, where you can do a second take and choose the best one. That is the job it is good at, and everything below assumes it.

Why the desk rig works better than it should

The webcam's usual weakness — it lives at the top of a screen, close to your face — is precisely what makes it a decent prompter rig. The script can sit closer to the lens than on almost any other setup, because the screen and the camera are already the same object. No glass, no mount, nothing to build: the whole discipline is in where you put the window and how you size the text.

The limits are real too. At desk distance your eyes are close to the lens, so the angle between "reading" and "looking at the viewer" is larger than it would be at two metres — the same words that read as eye contact across a room read as a slightly lowered gaze at arm's length. You cannot remove that entirely on a desk rig; you can shrink it until it stops mattering, which is what the next section is for. The eye contact guide has the full geometry.

Placement: the script goes under the lens, not beside it

Make the browser window narrow and park it at the top of the screen, centred under the camera. Under, not beside — vertical eye movement reads as thought; horizontal eye movement reads as reading. It is one of those asymmetries of the human face that costs nothing to exploit.

Then close the gap between the words and the lens. Shrink the window's height so the text sits in a shallow band right below the camera, and set the active line position high, so the line you are actually reading is the one nearest the lens — TellyPrompter lets you put the reading line where you want it, which on a desk rig means as close to the top of the window as it will go. Between a narrow band of text and a high active line, your eyes end up moving within a few degrees of the lens, which is the whole game.

Push your chair back as far as the desk allows and let the framing be looser, or crop in afterwards. Every centimetre of distance shrinks the eye-line angle further, and desk rigs are usually too close rather than too far.

Text and light at arm's length

Font size still wants to be larger than feels necessary — not for distance this time, but so the words land in glances and your eyes travel less. And remember the screen is a light source pointed at your face: a bright white page at arm's length glows onto you and reflects in glasses. A dark theme with light text fixes both, and photographs better.

The other desk-specific habit: raise the laptop. A laptop on the desk puts the camera below eye level, looking up at you — the least flattering angle available. A stand or a stack of books until the lens is at your eye line, and an external keyboard if you need to type, and the whole shot improves before you touch anything else.

Recording: in the browser or alongside it

You have two clean options and both are fine. TellyPrompter records in the app — MP4 or WebM, depending on the browser, with a split-screen or overlay layout if you want to see yourself — and a take is one press: the mic button starts recording and sets the script following you in the same act. Or run your usual recording software with the prompter simply being the top window; the prompter does not mind, and export of your scripts is free either way.

The reading itself is where the desk rig most needs the scroll to behave, because your hands are on show and the phone-as-remote trick does not exist here. Voice-following means there is nothing to operate once you start: the highlight tracks the word you are saying, waits through pauses and asides, and picks you up when you return. Speech recognition runs on the device and the audio is never uploaded. The honest limit, as ever: voice mode depends on the browser's speech recognition, which Firefox does not provide — constant and sound-level scrolling work there instead.

A last check

Before the first real take: camera at eye level, script window narrow and high with the active line near the lens, dark theme, notifications off, chair pushed back, one read-aloud pass done. Then record twice and choose. A desk rig will never be a beam-splitter — but for the videos most people actually record at a desk, it does not need to be, and it is difficult to beat a rig that costs nothing and is always already set up. When you outgrow it, the full setup guide and the iPad rig are the next rungs; the craft of filming yourself carries over whole.

This article explains why the question is harder than it looks, gives you the orientation figures people usually want, and lays out the three honest ways of setting a prompter's pace — in order of how much each one asks of you.

Why there is no right number

Speaking pace is not a constant, even within one person reading one script. You slow down for the point that matters and speed through the connective tissue. You pause when a sentence deserves it. You stumble, back up, and say the line again. A nervous first take runs faster than a warmed-up third. And pace shifts with language, with script density, and with how well the words fit your mouth.

A fixed scroll speed flattens all of that into a single average — and then makes you perform to the average. Set it slightly fast and you spend the take chasing the text, clipping your pauses because pausing costs you your place. Set it slightly slow and you stretch your delivery to fill, which produces its own strange, syrupy cadence. Either way, part of your attention is doing arithmetic against a conveyor belt instead of talking, and that divided attention is most of what audiences hear as a wooden read. We have a whole guide to reading naturally, and the scroll-speed guess is the villain of much of it.

So when someone asks for the right words-per-minute setting, the truthful reply is: the right speed is whatever you actually do in the take, and no prior number equals that.

The figures, for orientation only

They are still useful as a sense of scale, so, loosely: conversational English tends to sit somewhere around 130 to 160 words per minute, presenters often deliberately sit a little under their conversational pace, and dense or technical material wants to be slower than chat. Treat every such figure as orientation, never a target — pace varies by speaker, language and script, and performing to a number is precisely the trap this article is about.

The genuinely useful number is not universal but personal: what your script costs in minutes at your pace. TellyPrompter measures read-time from your own rehearsal rather than assuming a universal rate — read the script once in rehearsal mode and you know what it really runs, which is worth more than any rule of thumb when you are deciding whether a script fits the video you have planned.

The three honest ways to set the pace

A fixed scroll, when the material suits it. Constant mode — a steady words-per-second you choose — is the traditional approach, and it is genuinely fine for some jobs: short pieces, scripts you have read before, speakers who have learned to ride a scroll the way newsreaders do. Its cost is the one described above, and the cost grows with the length of the take and the newness of the script. If you use it, rehearse at least once at the set speed, and resist the urge to set it optimistically fast.

Sound-level scrolling, the halfway house. In sound mode the script advances while you are speaking and holds while you are silent, with a sensitivity control. It removes the worst failure of a fixed scroll — the text sailing on through your pause — without needing speech recognition at all, which also makes it the strongest option on browsers that lack one.

Voice-following, where speed stops being a decision. In voice mode, speech recognition listens as you read and the highlight tracks the word you are actually saying — through pauses, ad-libs, skipped lines and backtracking. There is no speed to set because there is no speed: the script moves exactly as fast as you speak, including not at all. Speech recognition runs on the device and the audio is never uploaded. Two honest limits: it depends on the browser's speech recognition, which Firefox does not provide — constant and sound modes work everywhere — and recognition quality is the browser's rather than ours, so it varies by platform, language and microphone. The full comparison of following versus scrolling goes deeper on when each earns its place.

So: what should you actually do?

If your prompter only scrolls at a fixed rate, do not look up a number — derive yours. Read the script aloud once, time it, set the scroll from that, and re-check whenever the script or your energy changes, because the figure is only ever true of the rehearsal it came from.

If the speed question is one you would rather stop answering altogether, use a mode where it does not exist. That is not a trick of framing; it is the design position this product is built on. A prompter should follow the speaker, and never ask the speaker to follow the app — and "how fast should it scroll" is exactly the question that disappears when it does. If you find yourself torn between memorising and prompting, that guide picks up where this one ends.

This guide covers the geometry, the placements available to you in rough order of cost, and the software settings that close the last few degrees.

Why your eyes give you away

The camera magnifies eye movement. A glance that feels imperceptible to you — a flick down to catch a line, a drift sideways to a second screen — is plainly visible in the footage, because the viewer is watching your face at a size and steadiness no live conversation provides. And the direction of the drift matters: downward glances read as reading or evasion, sideways glances read as distraction, while small vertical movement near the lens mostly passes as thought.

The instinct is to fix this with willpower — hold the lens, glance faster. It does not work, because the problem is angular, not moral. If the script sits thirty degrees from the lens, your eyes travel thirty degrees to read it, and the viewer sees every one of them. Move the script to five degrees from the lens and the same glance becomes invisible. That is the whole trick, and every placement below is just a way of buying smaller angles.

Distance does half the work for free

Before moving the script, move yourself. The angle your eyes travel depends on the gap between script and lens and on your distance from them: the same ten centimetres of gap is a large angle at arm's length and a small one at three metres. This is why a phone beside a camera works across a room and fails on a desk, and it is the cheapest improvement available — step back, let the framing loosen, crop in afterwards if you need to.

At one to three metres — the range most solo rigs end up at — text size becomes the constraint instead. The words have to land in glances and peripheral vision, which means bigger and bolder than any default. If you are squinting, the viewer can see that too.

The placements, honestly compared

Script under the lens. The strongest free option. Vertical eye movement is the kind viewers forgive, so a script directly below the camera — a narrow window at the top of a screen with a webcam above it, or a phone mounted just under a camera — keeps your gaze within a few degrees of the lens on the most forgiving axis. The desk setup guide is this placement in full.

Script beside the lens. Workable at distance, weak up close, because horizontal movement is the kind that reads as reading. If sideways is what your rig allows, distance matters even more, and the script should be as tight against the camera as physically possible.

Words on the lens axis. The complete solution is a beam-splitter rig: half-mirrored glass over the lens, so the script floats exactly where the camera is and reading is eye contact. It costs money or a weekend of building, and it brings its own rules — the glass eats a third to half the light, so text wants to be larger and bolder still, and the mirror flips everything, which is what mirror mode is for.

The software's share of the angle

Three settings close the remaining degrees, whatever the placement.

Active line position. The line you are reading is the only line your eyes need, so put it nearest the lens: at the top of the script area for an under-lens rig, wherever the lens axis falls on a beam-splitter. TellyPrompter lets you set where the active line sits rather than assuming the middle of the screen.

Look-ahead. Enough upcoming text to feel safe, not so much that your eyes wander down the page hunting the future. A shallow band of script keeps the eyes home.

A scroll that does not send your eyes hunting. The most common eye-line break is not a glance at the script — it is losing your place, and the visible search that follows. On a fixed scroll, every pause and stumble invites one. Voice-following removes the class of problem: the highlight sits on the word you are saying and waits when you stop, so there is nothing to find, and a glance at the script lands exactly where you are. Speech recognition runs on the device and the audio is never uploaded. The honest limit: it relies on the browser's speech recognition, which Firefox does not provide — the other scroll modes work there.

Practice the one habit that remains

With the geometry handled, one habit finishes the job: talk to the lens, not at it. Pick the small dark circle and treat it as a person's eyes — hold it the way you would hold a friend's gaze while making a point, which includes the natural tiny movements of a real face, not a fixed stare. If the talking head format is your home ground, that guide covers the delivery half; and if the read itself is what pulls your eyes loose, start with reading naturally. The geometry buys you the freedom; the talking is still yours to do.

All PromptSmart details below are taken from PromptSmart's own published pages in August 2026. Pricing and features move, so check their site before deciding.

What PromptSmart is

PromptSmart is an app suite from Belleau Technologies, built around VoiceTrack — their patented speech-recognition scrolling, which follows as you speak, pauses when you improvise, and resumes when you return to the script. Their pages state that audio is processed locally on the device, with no internet connection required for VoiceTrack.

The suite spans native apps: PromptSmart+ for iOS and Android, a Studio Edition for Windows and macOS, and a web portal for editing scripts and syncing them across devices. As published on their pricing page in August 2026, the Starter Pack subscription is $9.99 a month or $99.99 a year and covers the mobile and desktop apps, web-based editing, cross-platform sync and remote control; a Team tier at $19.99 a month or $199.99 a year adds multiple remote control room sessions and nested folders, with an Enterprise tier above that. There is also a longstanding standalone Pro app on the iOS App Store.

Where PromptSmart wins

Being honest about this is the point of the article, so plainly:

Native apps and a hardware-friendly ecosystem. If your workflow is a tablet locked into a rig running a dedicated app, with 4K recording on the device and a separate remote-control app or web control room driving it, PromptSmart is built for exactly that shape of production. TellyPrompter runs in the browser and has no remote-control companion — your voice is the remote, which suits a solo shoot and does not suit a producer driving the prompter for someone else.

Team and studio features. Control rooms, cloned displays, nested folders, sub-user administration — if a prompter is shared infrastructure in your organisation, their Team and Enterprise tiers address that directly. TellyPrompter is built for one person recording themselves.

Desktop apps as apps. Their Studio Edition is installed software for Windows and macOS. TellyPrompter installs as a PWA from the browser, which we would argue is a feature, but if your environment requires a conventional installed application, theirs is one.

Where TellyPrompter differs

The free tier is the whole prompter. TellyPrompter's voice-following, all 34 languages, mirror mode, the script library, and in-app recording without a watermark are free, with no account on the path from pasting a script to running it. PromptSmart's cross-platform suite is a subscription. We do keep a paid tier for cloud sync — the tier design, and what stays free and why, is its own article.

Nothing to install, on anything. Any device with a modern browser is already the prompter — the phone in your rig, the oldest tablet in the drawer, the laptop you are reading this on. It installs as a PWA if you want it to, and after the first visit the prompter works offline.

What the following unlocks afterwards. Because TellyPrompter tracks the word you are saying, every take carries per-word timing — which becomes script-accurate SRT and VTT captions with no transcription pass, a post-take stumble report showing where the read broke, and a measured read-time from your own rehearsal. If captions and take review are part of your week, this is the practical difference between the two products.

Languages and reading faces. Thirty-four languages with automatic detection, full left-to-right and right-to-left support, and OpenDyslexic as a first-class script face with the same sizing and reading states as the default.

On privacy, the honest note is that this is not a differentiator between these two: PromptSmart states VoiceTrack processes audio locally, and for TellyPrompter, speech recognition runs on the device and the audio is never uploaded. Both products let you read without your voice leaving the machine, which is how it should be.

The honest limits, ours included

TellyPrompter's voice mode rides on the browser's speech recognition, which Firefox does not provide — constant and sound-level scrolling work there, but if Firefox is non-negotiable and voice-following is the point, a native app avoids that constraint entirely. Recognition quality is the browser's rather than ours, so it varies by platform, language and microphone. And there is no remote control, no control rooms, and no team administration, by design.

How to choose

Choose PromptSmart if a producer or remote operator drives your prompter, if your organisation needs team administration, or if you want a native-app suite with 4K in-device recording and an established hardware ecosystem around it.

Choose TellyPrompter if you are one person recording yourself, you want the voice-following idea without a subscription or an account, and the after-the-take work — captions, stumble review, read-times — is where your hours actually go. The wider comparison of the category sets both against the rest of the field, and the case for voice-following itself is made in full there. The fastest way to compare is also the cheapest: open TellyPrompter in a browser, paste a script, and read — it costs nothing and needs no sign-up to find out.

All SpeakFlow details below are taken from SpeakFlow's own published pricing page in August 2026, on their yearly billing view. Pricing and plans move — check their site before deciding.

What SpeakFlow is

SpeakFlow is a polished online teleprompter built around Flow, their voice-activated scrolling, with script writing and organisation built in and a strong collaboration layer on top. It works across Windows, Mac, iOS and Android through the browser, with a desktop app available, and using it starts with creating an account.

As published in August 2026: the Free plan includes the teleprompter, auto scrolling, a limited version of Flow, script creation and formatting, and seven days of script history. Plus, at $15 a month billed once yearly, adds unlimited Flow, recording with one hour of video storage, an Overlay virtual teleprompter, bookmarks, voice commands, multi-device sync, AI writing tools, unlimited script history, commenting and real-time script collaboration, and API access. Studio, at $99 a month billed yearly, adds client workspaces for up to twenty-five members and ten hours of video storage. Monthly billing is available at higher rates on their monthly pricing view.

Where SpeakFlow wins

Collaboration is the real product. Real-time script collaboration, commenting, client workspaces, team membership — if scripts in your world are written by one person, approved by another and read by a third, SpeakFlow has built for that properly and TellyPrompter simply has not. TellyPrompter's library is one person's library.

The writing tools live inside it. AI writing assistance and revision history in the same place you prompt from is a genuine workflow convenience if you draft in the tool. TellyPrompter expects you to arrive with a script — from anywhere — and paste or import it.

Cloud video storage. SpeakFlow stores your recordings on their plans' terms, which means your takes are wherever you log in. TellyPrompter records to a local file you own and does not hold your video at all — we think that is the right default, but if takes-in-the-cloud is what you want, it is their feature, not ours.

An API. Plus includes API access. If you are wiring a prompter into a bigger system, that is a real door TellyPrompter does not have.

Where TellyPrompter differs

The free tier is the whole prompter, without an account. TellyPrompter's voice-following is not a limited taster — the full following engine, all three scroll modes, 34 languages with LTR and RTL support, mirror mode, the local script library and unwatermarked in-app recording are free, and there is no sign-up on the path from pasting a script to running it. SpeakFlow's free plan limits Flow and starts with account creation. We do keep a paid tier — cloud sync of the library across devices — and the reasoning behind what is free and what is not is its own article.

Offline on shoot day. TellyPrompter installs as a PWA, and after the first visit the prompter works offline — a room with no reliable wifi is a normal place to open it. The full piece on why offline matters on shoot day makes the case; for SpeakFlow's offline behaviour, check their documentation, as that is their claim to make, not ours.

Where recognition runs, stated plainly. For TellyPrompter: speech recognition runs on the device and the audio is never uploaded. We make no claim about SpeakFlow's implementation either way — their privacy policy is the place to check — but if that sentence is one you want to be able to say about your own setup, it is the one we can stand behind.

What the take leaves behind. Because the following engine knows which word you are on at every moment, each take carries per-word timing: script-accurate SRT and VTT captions with no transcription pass, a post-take stumble report, per-take timings, and a measured read-time from your own rehearsal. Voice commands — ending a take, retaking, dropping a stumble marker — are free rather than a paid-tier feature.

The honest limits, ours included

Voice-following in TellyPrompter depends on the browser's speech recognition, which Firefox does not provide — constant and sound-level modes work there — and recognition quality is the browser's, not ours, so it varies by platform, language and microphone. There is no collaboration, no cloud video, no AI writing and no API, and none of those are on the way as afterthoughts; the product is deliberately one person's prompter.

How to choose

Choose SpeakFlow if scripts are a team sport in your work — collaborators, clients, comments, approvals — or if you want writing tools, cloud-stored recordings and an API in the same subscription.

Choose TellyPrompter if you are one person recording yourself and you want the complete voice-following prompter free, working offline, with no account between you and a running script — and captions, stumble reports and read-times waiting when the take ends. The category-wide comparison covers the rest of the field. And since both products run in a browser, the honest advice is the cheap kind: open each one and read the same script aloud for two minutes. The one that follows you better is the answer, whatever either of us writes.

A scoping note first, because this page should earn trust rather than assume it: what follows describes what the product does, not outcomes for any group of readers. Reading difficulty is individual, and the only test that matters is reading your own script in it, which is free and needs no account.

OpenDyslexic is a script face, not a toggle

TellyPrompter ships OpenDyslexic as a first-class script face. That phrase is doing real work: it gets the same size range and the same reading states — the highlight, the active line, all of it — as the default face. It is chosen where you choose any font, not buried in an accessibility panel, and nothing about the reading experience is a reduced version when it is on.

Whether OpenDyslexic helps you personally is something only you can say — readers differ on it, honestly and famously. The point is that if it is your face, the product treats it as a first choice rather than an accommodation.

Your place is never carried by colour alone

The single most load-bearing element in a teleprompter is the mark that says you are here. Lose it and you have lost your place mid-sentence, on camera. So in TellyPrompter, no reading cue is carried by colour alone — position, weight and form do the work too, because roughly eight per cent of men cannot reliably resolve a colour-only distinction, and a highlight you cannot see is a prompter that does not work.

The same thinking sets the contrast. The product assumes it may be read through beam-splitter glass that has already taken a third to a half of the light, so nothing critical depends on a subtle tonal step. If your rig is just a phone on a desk, that headroom is still yours.

The scroll follows you, which changes who reading is hard for

A conventional prompter asks you to read at its speed. If reading aloud costs you more effort on some words than others — which is what reading difficulty is — a fixed scroll turns every hard word into a race, because the text keeps moving while you work.

TellyPrompter's voice mode follows instead: the highlight tracks the word you are actually saying, and when you slow down, stop, back up or re-say a line, it waits and picks you up. The pace of the take is whatever your pace is, sentence by sentence. Speech recognition runs on the device and the audio is never uploaded. The honest limits: voice mode relies on the browser's speech recognition, which Firefox does not provide — the constant and sound-level modes work there — and recognition quality is the browser's, so it varies by platform, language and microphone.

Alongside it, the practical companions: tap any word to jump there, a settable active-line position so the reading line sits where your eyes want it, look-ahead you control, and stop markers at sentence punctuation.

The rest of the reading surface is yours to set

Typography and spacing, text size well beyond timid defaults, colour themes, alignment, and full text direction — left-to-right and right-to-left, across 34 languages with automatic detection, including non-Latin scripts. Reduced motion is honoured: if your system asks for it, animation collapses to instant. And mirror mode is a proper whole-surface flip for prompter glass, so nobody is asked to read reversed text.

None of this is presented as a medical claim, because it is not one. It is a reading surface built on the assumption that readers differ, at every point where a prompter usually assumes they do not.

What this page deliberately does not say

You will notice this page does not claim a compliance standard. Our conformance target for the site and app is WCAG 2.2 Level AA, and it stays described as a target until complete user journeys have been audited — describing tested behaviour honestly seems more useful to you than a badge. And it does not claim that any tool removes the difficulty of reading aloud; a good one just stops adding to it.

If reading aloud to a camera is the thing you have been avoiding, the gentlest test is the real one: paste a few sentences, pick the face and size that suit you, and read them once with the scroll following you. The guide to reading naturally picks up from there, the language piece covers the 34 languages properly, and the free-tier article explains why all of the above costs nothing.