# How can a tech lead coordinate several teams without becoming the bottleneck?

> Move status, decisions and reviews out of your head and into writing, give each owner clear limits, and book your hands-on time before the meetings arrive

- Author: Ash Gaikwad (https://ashgaikwad.com)
- Published: 2022-08-19
- Topics: tech lead, leadership, engineering management, communication
- Canonical: https://ashgaikwad.com/blogs/how-can-a-tech-lead-coordinate-several-teams-without-becoming-the-bottleneck

A tech lead stops being the bottleneck by moving three things out of their head and calendar. These are what is happening, what was decided, and what each owner may decide alone. Put the status in a short weekly written update, keep a decision log for the choices that matter, and write down the limits within which each team can decide without asking. The time that comes back goes into hands-on work, and you book it before the meetings arrive.

I am Ash, a Staff engineer in Toronto. I have worked as a senior tech lead, I led a team of 7 that restructured a tangled MVC codebase in place with domain-driven design, and I have mentored 5+ engineers. In my current job I got a plan for a move from a monolith to services agreed with product, design, customer support and engineering directors. This article is for a tech lead whose desk collects every status question, decision and review. You get a way to see where work waits for you, written habits that replace most of the asking, and what they cost.

![Three kinds of question a tech lead can stop answering one by one. A status question is answered by a weekly written update. A decision question is answered by written limits and a decision log. A design question is answered by a design document that people read before the review. The time that frees up goes to hands-on work, booked in the calendar first.](/images/blogs/three-questions-a-tech-lead-stops-answering.svg)

## Find out where work waits for you

A bottleneck is a place where work waits for one person. For a tech lead it shows up in three ways. People ask you what is going on. Decisions wait for your yes. And you sit in every design review.

Count them for one week. Each time someone waits for you, write down the question and whether it was about status, a decision or a review. Each kind has a different fix, and this article follows them in that order.

Will Larson puts the goal in [create space for others](https://staffeng.com/guides/create-space-for-others/). One of the best measures of long-term success is that "the organization around you increasingly benefits from, but doesn't rely upon, your contributions". He calls it "a difficult transition from essential to adjacent".

Tanya Reilly calls the work around the code glue work in her talk [Being Glue](https://noidea.dog/glue), and her list includes "noticing when other people in the team are blocked". She says it is technical leadership. So the aim is not to stop doing glue. It is to choose which glue only you can do.

## Write a weekly update so status stops being a meeting

Use writing for information that flows one way, and meetings for disagreement. The answer to a status question exists before anyone asks it, so write it once and let people read it when they can.

Fixed headings tell people where to look. These are the five I would use.

1. What changed since last week.
2. Decisions made, each linked to its entry in the log.
3. Decisions needed, with the person who decides and the date it is needed.
4. Risks you can see that nobody has raised.
5. What you need from each other team.

Keep it to one page. An excerpt from the book Working Backwards, on Amazon's own page, says of its press-release and FAQ documents that "there are no awards for extra pages or more words", and that the goal is "to share the distilled thinking". Also keep one shared list of cross-team dependencies with an owner and a date on each line, and read it to find the line nobody owns.

Some meetings are still right, such as a written thread that goes two rounds without agreement. In the same [excerpt on aboutamazon.com](https://www.aboutamazon.com/news/workplace/an-insider-look-at-amazons-culture-and-processes) the writer hands out the document and everyone reads it to themselves before feedback starts, and "the most senior attendees tend to speak last, to avoid influencing others". If you are the most senior person in the room, that rule is yours.

## Keep a decision log

A decision log answers "why did we do it this way?" without you. Michael Nygard described the format in [Documenting Architecture Decisions](https://www.cognitect.com/blog/2011/11/15/documenting-architecture-decisions). It is one small document per decision, with a title, the context, the decision, its status and its consequences. He says "one of the hardest things to track during the life of a project is the motivation behind certain decisions".

The consequences section lists all of them, "not just the 'positive' ones", so the log is honest about what a choice costs. An old decision is marked as superseded and never deleted. Keep each entry short, because "large documents are never kept up to date".

Log the decisions that cross a team boundary or are hard to reverse, such as who owns which data and what a public contract promises. Leave out the rest, or the log becomes a chore. In my own work, writing down the standards took new-hire onboarding from 3 weeks to 2 days. A page that a newcomer can read is a question that never reaches you.

## Delegate decisions, with limits

The fix for "every decision waits for me" is to delegate the decision and say where the delegation ends. Larson writes that "at a certain point making the decisions isn't the work", and quotes Ritu Vincent, whose first instinct as a tech lead was to "assign out eighteen pieces, and keep the two hardest for myself", until her manager pushed her to hand over the hard pieces too.

The limits make this safe. Jeff Bezos wrote in his [2016 letter to shareholders](https://www.aboutamazon.com/news/company-news/2016-letter-to-shareholders) that "many decisions are reversible, two-way doors" and that "those decisions can use a light-weight process". Use that as the dividing line, and write it down once for each team or area, in three levels.

- The owner decides alone when the decision is easy to undo and stays inside the team, such as an internal design or a library choice.
- The owner decides and tells everyone in the weekly update and the log when other teams will feel it later but can live with it.
- The owner proposes and waits for review when the decision is hard to undo or crosses a boundary, such as a data model other teams read or an access rule.

Give the third level a deadline. The Rust project's [RFC process](https://github.com/rust-lang/rfcs/blob/master/README.md) ends discussion with a "final comment period" that "lasts ten calendar days, so that it is open for at least 5 business days". It does not need everyone to agree, and the window is the last chance to object. Borrow that. If nobody objects by the date, the owner ships, and your silence turns from a veto into a date.

A written standard is the largest form of delegation. I designed the organization-wide API standards behind a third-party apps platform, covering versioning, OAuth 2.0 app authorization with scoped tokens, webhooks and rate limits, and every engineering team builds against them. Nobody has to ask for approval to build an integration, because the standard already says what is allowed. The same thinking is behind the spec-first development with coding agents that I introduced. Engineers write and review the spec, agents write the code, and tests and review gates check every change before it merges.

Ask for a recommendation with every question, so "what should we do?" becomes "I would do this, any objection?". And separate being informed from being asked for permission, because many people ask for a yes when they only want you to know.

Delegation has a cost. Owners will decide things you would not have. Larson says sponsorship "includes letting them take an approach that you wouldn't", even if it "might end up going poorly". Only the first two levels are meant to be cheap to get wrong, which is why the third exists.

## Run design reviews on paper

A design review held only in a meeting makes you the reviewer, because you are the person who attends. On paper, the author writes the design down, circulates it with a date for comments, and calls a meeting only for the points where people still disagree.

Larson's habits fit here. Write the reasoning down so others "can begin to learn from our decisions rather than simply being directed by them", and circulate "before you've crystallized on a decision", because most people struggle to walk back from a formed opinion.

On the team of 7, I wrote the architecture documents and ran the design reviews. Today I would add one change, which is to ask a different person to run each review in turn, so the habit does not depend on me. The cost is that written reviews take more calendar days than a meeting, and some reviewers will not read, so the comment date is what moves a design on.

## Stop doing what the system can do

- Stop being the message bus. Answer a private question where the next person can find it, in the team channel or the log, and link to it next time. When two teams need each other, introduce them and step out.
- Stop being the only reviewer. Name two other people who can approve in each area.
- Stop weighing in on everything to justify your seniority.
- Stop holding the glue work alone. Share it and rotate it.

## Protect your hands-on time

Hands-on work keeps your judgment current. It is also the first thing that goes when the calendar fills up. Book blocks of half a day before the meetings arrive, because thirty-minute gaps are too short to load a codebase into your head. Batch the rest into set windows for questions and reviews.

In my opinion the work you take for yourself should not be on the critical path. Pick a tool, a prototype or a refactor that nobody waits on if you are pulled away. The hard pieces are where the team grows, and work that can slip is where you stay sharp.

## What it costs, and what I would not do

All of this costs time at the start, because the update, the first limits and the first log entries take hours before they save any. Teams will decide differently from each other, and the log is how you notice and converge later. A log that nobody keeps up is worse than none, because it looks reliable.

Three things I would not do instead. I would not be the single approver, because a queue grows with your calendar and not with the team. I would not hold a daily cross-team standup, because it spends everyone's time on status that a page can carry. And I would not write one large architecture document, because nobody updates a document that is too big to open.

## How to tell it works

Count again after a month. Fewer questions should wait for you, and the ones that do should be about disagreement and not information. Someone who was not in the room should find why a decision was made in the log, and each lead should be able to say what they can decide without asking you.

If nobody replies to the update, nobody reads it. If log entries appear after the work has shipped, the log records the past and does not help the next decision.

## A plan for the first month

1. In week one, list every question that waits for you and mark it as status, decision or review.
2. In week two, send the first weekly update with the five headings, and ask each team lead to write their own part from week three.
3. In week three, write the three levels for the two or three kinds of decision people ask you about most, and open the log with the next real decision.
4. In week four, move one design review onto paper with a comment date, and book your hands-on blocks.

If your work spans a whole initiative and not only a few teams, I wrote about [leading a technical initiative across several teams](/blogs/how-do-i-lead-a-technical-initiative-across-several-teams). For the same idea where the limit is a gate that a coding agent cannot skip, see [how I run my products with AI agents](/blogs/how-i-run-my-products-with-ai-agents).

The best sign that this works is a quiet inbox and a pull request you wrote yourself.

## Frequently asked questions

### Should a tech lead use written updates or meetings to coordinate several teams?

Use written updates for status and for decisions that need a trace, and meetings for disagreement and sensitive topics. When a meeting is needed, share the document first and let the most senior person speak last.

### What goes in a decision log?

One short entry for each decision that crosses a team or is hard to undo. In Michael Nygard's format each has a title, the context, the decision, a status and the consequences, both good and bad.

### How do I delegate when I do not yet trust the team's judgment?

Start with decisions that are easy to undo, and write down what happened. Move a kind of decision up a level when the record supports it.

### What is the difference between being informed and giving approval?

Being informed means you read about the decision afterwards and can raise a concern. Giving approval means the work waits for you. Most decisions only need the first.

### How much should a tech lead still code?

Enough to keep your judgment current, in work that nobody waits on.
