Login
Back to Blog
Remote WorkAsyncDistributed TeamsCommunication

When to Turn a Thread Into a Call

Rajat KapoorNovember 22, 20269 min read

The thread was about whether to change a database column type, and it ran for four days. Dev in Singapore raised the question on a Monday afternoon his time. The engineer who owned that service was in Toronto, so he read it Monday night Singapore time, which was Monday morning for him, and replied with a clarifying question. Singapore saw the reply Tuesday. Answered it. Added a caveat. Toronto read the caveat Wednesday, realized the caveat changed everything, and asked a second question. By Thursday the thread was nineteen messages long, two people were mildly annoyed, and the actual disagreement, once someone finally said it out loud on a call, took eleven minutes to resolve. Four days of elapsed time for eleven minutes of talking. Nobody was slow. Every reply came within a working day. The thread was just the wrong tool, and it took four days to admit it.

That is the tax almost nobody prices. On a co-located team you never see it, because escalating from typing to talking costs you one swivel of your chair. You lean over, you ask, it's done. Remote deletes the swivel, and the question of when to stop typing and start talking becomes a real decision with a real price on both sides.

A call is a bill someone pays in sleep

Start with the thing that makes this hard. In an office a call is nearly free, so you reach for it on instinct the second a thread gets annoying. That instinct is wrong on a distributed team, and importing it unexamined is how you end up scheduling six meetings a week that each land at 10pm for somebody.

A live call across a wide timezone gap is one of the most expensive things your team can spend. It costs scheduling friction, it costs the context-switch of everyone stopping what they're doing, and most of all it costs someone their evening or their early morning, because when your overlap window is ninety minutes wide, every call gets crammed into it or spills outside it onto one person's bad hour. The overlap hour is the scarcest thing the team owns, and a call withdraws from that account.

So the bar for escalating is higher than it would be in an office, in both directions at once. You tolerate more async friction before you pull the ripcord, because the ripcord is costly. And when you do pull it, the thing on the other end had better be worth someone's night. Holding both of those at the same time is the whole skill.

The signals a thread has earned a call

The clearest signal is round-trip count. A healthy async thread converges: question, answer, done, or at most one clarification and then done. The thread that is quietly failing is the one that keeps generating new questions instead of closing old ones. Watch for the third round trip. If you're on exchange three and the thing is wider open than when you started, stop, because each of those round trips is not a minute, it's a sleep cycle. A thread that needs five exchanges to resolve is a full week on a team nine hours apart, and you can feel it curdling the whole way. Count the round trips, not the messages: two people typing in the same hour can rack up twenty and still be converging.

The second signal is tone. Text strips out everything that would reassure you the other person isn't irritated, and a flat reply read alone at the wrong hour reads colder than it was meant. When a thread starts to feel tense, that feeling is usually the medium, not the people, and continuing to type into it just lets the resentment compound in the dark. The move there is to get the two humans hearing each other's actual voices before the imagined argument hardens into a real one. A call won't just resolve it faster. It'll resolve a different, smaller problem than the one the thread was inventing.

The third signal is genuine ambiguity, the kind where nobody yet knows the right question to ask. Async is superb at exchanging answers and clumsy at the fast, exploratory back-and-forth where an idea gets built by two people interrupting each other. If you're three paragraphs into writing a message and you realize you don't actually understand the problem well enough to frame it, that's not a message, that's a conversation you haven't had yet. That's also the whole case for keeping some live pairing time: some work is actively worse async, not merely slower.

The opposite mistake is just as common

Everything above pushes toward calling sooner. Now the counterweight, because the more frequent failure on most teams I've watched is the reflexive call, not the stubborn thread.

"Quick call?" is the message, and it arrives for a thing that was one clear question with one clear answer. The sender didn't want to take the two minutes to write the question properly, so they externalized that cost onto everyone's calendar and, usually, onto one far-timezone person's evening. A call is not a substitute for thinking through what you're actually asking. Most threads that stall don't need a call. They need a better-written message, one that leads with the ask, states the decision you're driving at, and pre-answers the obvious follow-up, so the reader can close it in a single pass instead of volleying.

Here's the discipline I'd put on it. Before you ask for a call, write the message you'd have sent anyway, the full one, with your actual question and your best guess at the answer. Half the time, writing that message dissolves the need for the call, because the act of making it clear enough to send makes the answer obvious. If it survives that test and you still think a live conversation is faster, now you've earned the call, and you've also got the written context to send ahead of it so the call doesn't start from zero.

When you do escalate, do it fairly

Say the thread has earned it. There are still two ways to blow it.

The first is making the same person always pay. If the natural answer to "when can we talk" keeps landing on the one teammate who's farthest out, you've found the default that quietly punishes them for being inconvenient. Spread the awkward slot the same way you would for any recurring meeting. Someone eats a bad hour for an unplanned call, and over a quarter it should not always be the same someone.

The second is letting the call vanish. Two people hop on, sort it out in eleven minutes, feel great, and close their laptops, and now the resolution lives in exactly two heads, both of which belong to people who happened to be awake. For the third of the team that was asleep, the four-day thread they'd been following just went dark and came back decided, with no trace of how. So the last minute of any escalated call is a note dropped back into the original thread: here's what we decided, here's why, here's what's still open. A call that resolves something and then disappears has only moved the decision out of reach of whoever couldn't attend. The written trail is what makes the live conversation legitimate on a team where someone is always missing from the room.

When a call genuinely can't be scheduled, because the overlap is zero and nobody should wake at 4am for a column type, the middle rung is a short recorded walkthrough. Three minutes of screen and voice carries tone and visual context that text can't, and the receiver watches it on their own clock. It isn't as good as talking, but it beats a nineteen-message thread.

The manager's part

If you run the team, watch what you reward, because people copy the escalation habits of whoever's in charge. A manager who answers every ambiguous thread with "let's hop on a call" trains the team to stop writing clearly and start booking time, and that tax falls hardest on the people furthest from the manager's clock. A manager who lets tense threads smolder for a week rather than spending one awkward call trains everyone to suffer in text.

The job is to model the judgment, not a rule. Let most things stay async, write the clear message instead of calling, and then, for the thread that's circling or fraying or genuinely lost, be the one who says "this has earned a call" and schedules it somewhere fair. The skill was never async versus sync. It's knowing the price of each and paying it on purpose, instead of reaching for whichever one your old office instincts hand you.


Related Reading


Let Timely Handle the Clock Math

The moment you decide a thread has earned a call, you hit the other problem: when. "Can we talk at 3?" means nothing to the person nine hours out who now has to do the offset in their head before they know whether you're asking for their afternoon or their midnight. Timely reads each person's Slack timezone and converts every time mentioned into the reader's own local clock, so picking the hour for an unplanned call takes seconds instead of a round of "wait, 3 your time or mine?" It won't tell you which threads to escalate. It makes scheduling the call you've decided on the easy part.

Add Timely to Slack — Free  ·  See how it works