You get a coding problem.
You understand it. You have an idea. So you open your editor and start writing.
Five minutes later, you have a working solution — but the interviewer has barely heard you say anything.
That can be a problem.
A technical interview isn’t only about whether you can produce working code. The interviewer also needs to understand how you approach problems, make decisions, deal with uncertainty, and respond when your first idea doesn’t work. Thinking out loud is one way to make that reasoning visible.
But there is a common misunderstanding here.
Thinking out loud does not mean saying everything that goes through your head.
In fact, trying to narrate every thought can make an interview harder, especially when you’re working in a second language. The goal is not to provide a running commentary on your brain. The goal is to give the interviewer enough information to follow your reasoning.
Imagine you get this problem:
Given an array of numbers, return the first value that appears more than once.
A nervous candidate might say:
“Okay, maybe I can use an array… actually no, maybe a map… hmm, sorting could work… but then I lose the order… maybe I should…”
There is some thinking happening here, but not much useful communication.
Compare that with:
“We need to return the first duplicate, so preserving the original order matters. My first thought is to use a set of values we’ve already seen. That would let me check each value as I go.”
Now the interviewer knows what you’re thinking and why.
That’s the difference.
Good thinking out loud usually consists of assumptions, decisions, questions, and changes in direction — not every half-formed idea that crosses your mind. This middle ground comes up repeatedly in discussions among software engineers about technical interviews.
You don’t have to talk constantly.
You just need to make the important parts of your thinking visible.
One of the easiest mistakes in a technical interview is starting to code too quickly.
Before touching the keyboard, make sure you understand what you’re actually being asked to do.
For example:
“So I need to return the first duplicate value, rather than all duplicate values. Is that correct?”
Or:
“Can the input contain negative numbers?”
Or:
“Should I preserve the order of the original array?”
These aren’t just English phrases to memorize. They’re useful questions because the answers can change your implementation. The point is to clarify things that matter to the solution, rather than asking questions simply to keep the conversation going.
If you understand the problem, say so briefly and move on.
Before writing code, give the interviewer a quick idea of where you’re going.
Something as simple as:
“I’ll use a set to keep track of the values I’ve already seen. I’ll iterate through the array, check whether the current value is already in the set, and return it if it is.”
That’s enough.
You don’t need a five-minute explanation of the algorithm before writing the first line.
The benefit is that the interviewer now has a mental model of your solution. If you make a mistake later, they can see where your reasoning changed. And if you get stuck, they have something concrete to discuss with you.
It also gives you an opportunity to catch your own mistakes.
Suppose you explain:
“I’ll sort the array first and then look for adjacent duplicates.”
As you say it, you realize that the problem asks for the first duplicate in the original order.
You can catch the problem before you’ve written twenty lines of code.
You don’t need to say:
“Now I’m declaring a variable called
seen.”
The interviewer can see that.
Instead, explain decisions that aren’t obvious from the code.
For example:
“I’m using a set here because I only need to know whether we’ve encountered this value before.”
Or:
“I’m checking before inserting because we want the first duplicate.”
Or:
“I’m using a map instead of a set because I also need to store the index.”
A useful rule is:
If the interviewer can see it, don’t waste time describing it. Explain why you did it.
This is particularly useful when English isn’t your first language. You don’t need to produce a continuous stream of fluent English while simultaneously solving a difficult programming problem. You can pause, code, then explain the important decision you’ve just made.
That is a much more manageable task.
“Think out loud” can make people feel that they have to keep talking every second.
You don’t.
Sometimes you need to stop and think.
It is completely reasonable to say:
“Give me a moment to think about this.”
Then stop talking.
A few seconds of silence is very different from leaving the interviewer in complete uncertainty for several minutes. Discussions from experienced software engineers include both sides of this distinction: interviewers often want to see the reasoning, but candidates also need room to think without turning every pause into nervous rambling.
You can even make the process explicit:
“I have two possible approaches. Let me think through which one fits the constraints better.”
Then take a moment.
There is nothing strange about that.
In fact, being comfortable with a short pause can make you sound more deliberate.
This is one of the most important parts of technical interviews.
You will sometimes choose the wrong approach.
That’s normal.
What matters is what happens next.
Suppose you start with a nested-loop solution and then realize that the input can contain hundreds of thousands of elements.
Don’t try to hide the problem.
Say:
“This works, but it gives us O(n²) time. Given the input size, that’s probably too expensive. Let me look for a way to do this in O(n).”
You’ve just demonstrated something more useful than simply producing a correct answer: you noticed a limitation and adjusted your approach.
The same applies if you make an assumption that turns out to be wrong:
“I was assuming the array was sorted, but that’s not actually guaranteed. Let me go back and rethink that.”
One of the recurring points in the Stack Exchange discussion is that getting onto the wrong path is not necessarily a problem. A candidate who notices the problem, acknowledges it, and changes direction is showing part of the actual problem-solving process.
Donny Wals makes a similar point from a practical interview perspective: if you get stuck, it’s better to be honest and work through the problem than to bluff your way through an answer.
You don’t need to memorize an interview script. But having a few reliable phrases available can make it much easier to explain your thinking under pressure.
To clarify
“Let me make sure I understand the requirement.”
“Can I assume that…?”
“Should I return the first duplicate or all duplicates?”
To explain an approach
“My first thought is to…”
“I’ll use X because…”
“The main reason for this approach is…”
To think
“Give me a moment to think about this.”
“I see two possible approaches here.”
To change direction
“Actually, I don’t think that will work because…”
“I just noticed an issue with this approach.”
“Let me back up and try a different approach.”
To test
“Let’s run through a simple example.”
“One edge case I’d like to check is…”
These phrases aren’t there to make your English sound impressive.
They’re there to give structure to your communication.
Let’s go back to the duplicate-number problem.
A strong interview conversation might sound something like this:
“So I need to return the first value that appears more than once. I’ll assume the input can contain negative numbers and duplicates, but the array itself isn’t necessarily sorted.”
“My first thought is to use a set. I’ll iterate through the array and check whether each value is already in the set. If it is, I return that value; otherwise, I add it to the set.”
“This gives us O(n) time and O(n) additional space.”
“I’ll code that up.”
[write the solution]
“Let’s test it with
[3, 1, 4, 3, 2]. We see 3 twice, so the function should return 3.”“An empty array should just return no result.”
Notice what isn’t happening.
There is no narration of every variable declaration. There is no attempt to fill every second with speech. There is no elaborate explanation of basic syntax.
The candidate is simply keeping the interviewer informed about the parts of the solution that matter.
For a native English speaker, this kind of conversation may feel fairly natural.
For a non-native speaker, there is an extra layer.
You are solving the problem, remembering syntax, evaluating complexity, listening to the interviewer, and trying to construct sentences in English at the same time.
That can make a capable developer sound much less confident than they actually are.
The answer isn’t necessarily to learn more vocabulary.
Often, it is to practice explaining technical decisions in English.
You already know what a hash map is. The challenge is being able to say, under pressure:
“I’m using a hash map because I need constant-time lookups.”
You already know why a solution is O(n).
The challenge is being able to explain:
“The loop runs once over the input, so the time complexity is O(n).”
You already know when an approach doesn’t work.
The challenge is being able to say:
“That won’t work because we’re not guaranteed that the input is sorted.”
Those are communication skills, but they’re tightly connected to your technical skills.
Here’s a useful exercise.
Take a coding problem you’ve already solved.
Solve it again while recording yourself.
Don’t try to sound like a native speaker. Don’t try to use complicated vocabulary. Focus on communicating five things:
What is the problem?
What approach are you considering?
Why did you choose it?
What changed when you discovered a problem?
How did you test the solution?
Then listen back.
Don’t ask yourself:
“Was my English perfect?”
Ask:
“Could another developer follow my reasoning?”
That is much closer to what you are trying to accomplish in the interview.
Technical interviews put an unusual amount of pressure on communication because you’re expected to demonstrate what you know while you’re actively using it.
For non-native English speakers, that can create a frustrating gap between being capable and looking capable in an English interview.
Thinking out loud helps close that gap.
Not because talking is inherently better than thinking silently, and not because you need to narrate every thought.
The goal is simpler:
Make your technical thinking visible.
Explain the assumptions that matter. Explain why you chose an approach. Ask questions when the requirements are unclear. Give yourself time to think. And when something goes wrong, say what went wrong and work through it.
You don’t need perfect English.
You need to give the interviewer a clear window into how you solve problems.