How does async decision-making work in distributed teams?

Async decision-making isn't a meeting moved into a document. It's a different mechanism: instead of resolving a question with simultaneous attention, you resolve it with a written proposal, a fixed window for input, and one person accountable for the call. Done right, it's both faster and better-documented than the meeting it replaced.

Why distributed teams can't decide by meeting

Across three timezones, "let's hop on a call" means either a two-week scheduling delay or a decision made by whoever happened to be awake. Both failure modes teach people to stop raising decisions at all. Synchronous deciding also leaves nothing behind: the reasoning lives in a call recording nobody replays.

The classic async failure is just as real, though: the thread that runs for two weeks, gathers thirty comments, and decides nothing. That thread is missing two components, a decider and a deadline, and more comments supply neither.

What actually works

Sort decisions by reversibility first. Jeff Bezos's 2015 shareholder letter split decisions into Type 1, irreversible one-way doors that deserve slow deliberation, and Type 2, reversible two-way doors that should be decided quickly by small groups, because you can walk back through. Async is the natural home of Type 2 decisions, which is most of them. Save synchronous bandwidth for the one-way doors.

Open with a proposal, not a question. "What should we do about X?" produces a discussion. A one-page proposal (context, options considered, a recommendation, and the deadline) produces a decision. Writing the proposal forces the author to do the thinking a meeting usually defers.

Name the decider in the proposal. Input is open to everyone affected; the verdict belongs to one person. Written consensus among n people is a coordination problem that grows with n; one accountable integrator is what makes the deadline meaningful.

Set a real deadline with a silence-means-consent default. Give every timezone at least one working day. When the window closes, the decider decides with the input that arrived: no quorum requirements, no waiting for stragglers. People learn quickly that the window is when their voice counts.

Separate the decision from the discussion. The thread is the debate; the decision is its own findable artifact: verdict, reason, rejected alternatives, owner, date. GitLab's handbook-first rule makes this concrete: a decision isn't done when it's made, it's done when it's written where the next person will look. Reversals get a successor entry, and Type 2 calls that might age badly get a review date. The entry format is the same four fields that make an engineering decision log work.

Escalate deliberately, not accidentally. If an async thread turns contentious or circular, that's the signal it was secretly a one-way door. Move it to a call, then write the outcome back into the record like any other decision.

If your team ships software, Lockstep applies this model to product and engineering decisions: capture, one accountable approval, and a findable record.