AlgoMaster Logo

How to Communicate During Interviews

Last Updated: March 31, 2026

Ashish

Ashish Pratap Singh

Many candidates don’t get offers even when they know the optimal solution. The problem is rarely the solution itself. It’s how they communicate.

In an interview, your thinking matters just as much as your code. If you work through the problem silently and only present the final answer, the process behind it is lost. The interviewer misses how you approached the problem, how you handled trade-offs, and how you would work with others in a real setting.

The good news is that this is a skill you can build. You don’t need to be naturally talkative or polished. You just need a simple, consistent way to walk through your thought process so it becomes easy for someone else to follow along.

Why Communication Matters More Than You Think

Imagine two candidates working through the same problem.

Candidate A reads the question, stays quiet for a few minutes, and then writes a correct O(n) solution. When asked, “why did you use a hash map?”, they reply, “because it’s faster.”

Candidate B takes a different approach. They start by saying, “we’re looking for pairs that sum to a target, so this feels like a complement problem.” They clarify a few edge cases, briefly walk through a brute-force idea, explain why it’s O(n²), and then naturally move to a hash map solution, explaining how it improves the time complexity to O(n).

Both candidates arrive at the same answer.

The difference is that Candidate B makes their thinking visible. You can follow their reasoning, see how they break down the problem, and understand why they made each decision. It feels less like watching someone type code and more like working through a problem with a teammate.

Phase 1: Asking Clarifying Questions

When you first hear the problem, it’s tempting to jump straight into coding. Pause for a moment.

Spend a minute or two asking a few thoughtful questions. It helps you avoid unnecessary mistakes, clears up ambiguity early, and gives you a clean starting point before you begin solving.

What to Ask

  • Input constraints: "What is the range of input sizes? Can the array be empty? Can values be negative?" These questions help you avoid running into edge cases halfway through your solution.
  • Expected behavior. "If there are multiple valid answers, should I return any one of them or all of them? What should I return if no solution exists?" Small ambiguities like this can completely change your implementation.
  • Data characteristics. "Is the input sorted? Are there duplicate values? Can I assume the input fits in memory?" These questions directly influence which approach makes the most sense.
  • Modifications allowed. "Can I modify the input array, or should I treat it as read-only?" This affects whether in-place algorithms are viable.

Example: Two Sum

Here’s how a strong candidate might begin:

In just a few sentences, they’ve clarified the problem, removed ambiguity, and set themselves up for a smoother solution. This usually takes under a minute.

Questions to Avoid

Avoid asking things that are already clearly mentioned in the problem. It makes it seem like you didn’t read it carefully.

Also avoid open-ended questions like “any hints?” before you’ve even tried to think through the problem. It’s better to take a moment, gather your thoughts, and then ask more focused questions if you get stuck.

Phase 2: Explaining Your Approach Before Coding

This is one of the most important moments in the interview.

Before you write any code, take a few seconds to explain what you’re planning to do and why. It helps you organize your thoughts and makes the rest of the interview feel much smoother.

A Simple Structure That Works

A good approach explanation follows this pattern:

  1. State the core observation: What’s the key insight behind your approach?
  2. Mention the technique (if applicable): If this is a known pattern like sliding window, two pointers, or BFS, call it out.
  3. Walk through the high-level steps: Keep it simple. Think 3 to 5 steps, not detailed pseudocode.
  4. State the complexity: Give a quick sense of time and space, and why.

Example: Approach Explanation

That’s it. About 20 seconds.

In that short explanation, you’ve shown how you think, how you move from a basic idea to a better one, and that you have a clear plan before coding.

When the Interviewer Pushes Back

Sometimes the interviewer will say "can you think of another approach?" or "what about the space complexity?"

Don’t treat this as a signal that you’re wrong. It’s just the conversation going deeper.

Phase 3: Narrating While Coding

Once you start coding, try not to go completely silent.

It’s natural to focus and get lost in the code, but long stretches of silence make it hard for someone else to follow what’s happening. A little bit of narration goes a long way in making your thinking visible.

The goal isn’t to explain every line. Just give enough context so that someone watching you can follow your decisions.

What to Narrate

  • Structural decisions: "I'll start by initializing the hash map, then iterate through the array." This shows you are following the plan you described.
  • Why you chose something: "I'm using a HashMap here instead of an array because the values could be negative or very large." This makes your decisions feel intentional, not random.
  • When you are handling edge cases: "Let me add a check for an empty array at the top." This shows you’re thinking beyond the happy path.
  • When you change direction: "Actually, I realize I need to check the complement before inserting, not after, otherwise I might match an element with itself." This is one of the strongest signals you can give. Catching and fixing your own mistake in real time is a very real-world skill.

What Not to Narrate

Don’t read your code line by line. “Now I’m declaring i, incrementing i…” doesn’t add value.

Also avoid filling every pause with “let me think…” repeatedly. Taking a short pause is completely fine. Over-explaining every second is not.

Finding the Right Balance

Think of it like this: mostly coding, with small bursts of explanation.

You write a few lines, then briefly explain what you just did or what you’re about to do next. It should feel natural, like you’re walking someone through your thinking, not giving a lecture.

You don’t need to talk constantly. But try not to disappear into silence for too long either.

Phase 4: Discussing Trade-Offs

Once your solution is working, the conversation usually doesn’t end there. This is where you can go a level deeper and show how you think beyond just “getting it to work.”

A common direction is to talk about trade-offs. Not as a formality, but as a way to explore how your solution behaves under different constraints.

Trade-Off Categories

CategoryWhat to Discuss
Time vs Space"We could reduce space to O(1) with a two-pointer approach, but that requires sorting the input first, which adds O(n log n) time."
Simplicity vs Performance"The recursive solution is cleaner, but the iterative version avoids stack overflow for large inputs."
Generality vs Specificity"This works for any hash-able type, but if we know the inputs are small integers, we could use an array for better cache performance."
Preprocessing vs Query Time"We spend O(n) upfront to build the hash map, but each lookup is O(1). If we had multiple queries, this amortizes well."

How to Bring Up Trade-Offs Naturally

You don’t need to wait for someone to ask. Once you’ve confirmed your solution works, you can add:

This kind of reflection shows that you’re not just solving the problem, you’re thinking about how the solution behaves in different situations.

Signaling When You Are Stuck vs Silent Struggling

Getting stuck in an interview is completely normal. What matters is how you handle that moment.

The Wrong Way: Going Silent

When people get stuck, they often go quiet and try to figure everything out internally.

The problem is, from the outside, it’s hard to tell what’s going on. Are you close to the solution? Are you going in the wrong direction? Are you completely blocked?

After a minute or two of silence, it just feels like the conversation has stalled.

A Better Approach: Think Out Loud

When you hit a wall, just say what’s going through your mind.

For Example:

That alone makes a big difference. It shows the direction you’re thinking in, highlights exactly where you’re stuck, and keeps the conversation going.

Asking for Hints the Right Way

There’s a big difference between:

“I’m stuck, can you give me a hint?”

and

“I’m considering using a priority queue here, but since all edges have equal weight, I’m wondering if a regular queue would work just as well. Does that make sense?”

The second one shows you’ve already thought through the problem and just need a small nudge.

A Communication Framework You Can Practice

If this feels like a lot to keep in mind, don’t worry. You don’t need to remember everything. Just practice a simple flow like this until it becomes natural.

  1. Repeat the problem in your own words. ("So we need to find...")
  2. Ask 2-3 clarifying questions. ("Can the input be empty? Are there duplicates?")
  3. Brute force first. State the obvious approach and its complexity.
  4. Optimize with an explanation. State the key insight that improves the solution.
  5. Confirm with the interviewer. ("Does this approach sound reasonable?")
  6. Narrate as you code. Explain blocks, not lines.
  7. Test out loud. Walk through an example with your code.
  8. Discuss trade-offs and extensions.