🇦🇪 HireDeveloper.ae

3 Engineers, 40 Minutes, One Lost Decision: the 7-Step Communication Charter I Wrote for Our Dubai Team That Night

Developer workstation with code on two monitors in a darkened room, representing a distributed Dubai engineering team working to a written communication charter
Sebastian

Sebastian

Mobile App & Hiring Expert · November 15, 2026 · 11 min read

TL;DR

  • •The problem: On a distributed team, the expensive failure is not slow replies. It is decisions that exist only inside a conversation, so every new question restarts an old argument.
  • •The method: Seven steps, in this order. Decision record first, then one job per channel, response times attached to channels rather than people, a protected overlap window, escalation to a named person, a written bar for synchronous time, and a quarterly review against real incidents.
  • •The constraint that makes it work: One page. If the charter grows past a page, it has become a record of old arguments instead of a working agreement, and people stop reading the parts added last.

The meeting that produced this document was not about communication. It was a design review, and it stalled because three engineers could not agree on whether we had already decided to keep a particular service separate. Two of them went looking. Forty minutes later they produced a chat thread from seven weeks earlier in which the decision had been made, by two people, neither of whom was in the room, with the reasoning spread across eleven messages and one screenshot. The decision had been correct. Nobody could find it, so it was worth nothing.

That evening I wrote the first version of what we now call the communication charter. It is one page. It has survived four quarters and three new hires, and the thing I got wrong in the first draft is the thing most teams get wrong: I started with channel rules, and channel rules are step two.

Why the Order of These Steps Matters More Than Their Content

Almost every communication document I have read inside a company starts by assigning tools. Chat for quick questions, email for external, the issue tracker for work, video for discussions. It is sensible and it does not work, because it treats the problem as routing when the problem is persistence.

Channel rules tell a message where to go. They say nothing about where the output of that message should end up. A perfectly routed discussion in exactly the right channel still produces a decision that lives inside a conversation, and conversations are searchable in theory and unfindable in practice. So the first rule has to be about where decisions come to rest, and only then does it make sense to argue about which room the argument happens in.

This matters in Dubai for a specific reason. Teams built here are distributed by default rather than by exception, which is different from being remote-friendly. A Dubai team typically spans the Gulf working hours, several hours east, and sometimes several hours west, and the working week does not line up neatly either. In that configuration a decision that exists only in a conversation is not merely hard to find: it is inaccessible to a third of the team for most of the day. The timezone mechanics sit in our method for managing timezone overlap on a remote developer team in Dubai.

Two ways to write the same documentThe difference shows up six weeks later, not in the first weekChannel rules firstDecision record firstQuestion goes to the right channelRouting solvedQuestion goes to the right channelRouting solved the same wayDiscussion happens, decision is reachedEveryone present agreesDiscussion happens, decision is reachedPlus one line written to the logWeek 7: the decision cannot be foundThree people re-argue it from scratchWeek 7: one search, one line, doneIncluding the reason, which is the valuable partBoth teams communicated well. Only one of them can prove what it decided.This is why persistence comes before routing in the charter

The 7 Steps, in Order

Step 1: Write the decision record before any channel rule

Pick one location where decisions come to rest, and make it independent of where the discussion happened. We use a flat file in the main repository, appended to, never reorganised. Other teams use a dedicated space in their wiki or a labelled issue type. The medium matters much less than two properties: it must be searchable by someone who does not know the vocabulary used at the time, and it must be writable in under two minutes, because anything slower will not survive a busy week.

The entry format we settled on is four fields: the date, the decision in one sentence, the reason in one or two, and who to ask. That last field is the one people skip and the one that pays off, because the common question six months later is not what we decided but whether the constraint behind it still holds, and that is a question for a person rather than a document.

Write this rule first, and write it as an obligation attached to the decision rather than to a role. Whoever makes the call logs it within one working day. Not the manager, not a scribe: the person who decided.

Step 2: Give every channel exactly one job, and say what must never go there

Now the channel rules, and the second half of this step is the half that works. Listing what a channel is for produces agreement and no behaviour change. Listing what must never go there produces arguments, and the arguments are the point, because they surface the places where two channels currently overlap.

Our version is short. Chat is for things that stop being useful tomorrow, and design decisions must never go there. Pull request comments are for anything about specific code, and personnel conversations never. The issue tracker is for committed work, not speculative ideas, because a backlog full of maybes is a backlog nobody reads. Video is for disagreement and for people, never for status.

A channel with two jobs collapses into the easier one, and the easier one is always chat. That is the failure mode to design against: not people using the wrong tool, but a harder, slower, more valuable kind of communication quietly ceasing because an easier channel absorbed its traffic.

Step 3: Attach response times to channels, not to people

Write a published response window next to each channel. Ours: chat within four working hours and no expectation outside them, pull request review within one working day, issue tracker comment within two, and the escalation path in minutes. Nobody has a personal response-time commitment.

This sounds like a small administrative distinction and it changes the emotional weather of a distributed team more than anything else on the list. When expectations attach to people, every unanswered message is a judgement about a colleague, and engineers outside Gulf hours develop a low-grade anxiety about looking unresponsive while legitimately asleep. When expectations attach to channels, an unanswered message at 9pm is just a message in a channel whose window has not started.

The rule that makes this real is the one about what happens when the window is not enough: if you need an answer faster than the channel promises, you do not send a faster message in the same channel, you use the escalation path in step five. Without that, the response windows become advisory and the team reverts to pinging.

Step 4: Define the overlap window and reserve it

Find the hours when the whole team is genuinely available, state them in one timezone, and write the short list of things that may only happen inside them. For us that list has three items: decisions where there is live disagreement, design conversations with unresolved trade-offs, and anything involving feedback to a person. Everything else is explicitly banned from the window.

The banning is the active ingredient. An unprotected overlap window fills with status meetings, because they are easy to schedule and nobody objects in the moment. Within a quarter the only shared hours the team has are consumed by its lowest-value synchronous activity, and the design conversation that needed everyone gets pushed to a thread.

Keep the window honest about its length. If the real overlap is two hours, write two hours. A charter claiming a four-hour window that only three of eight people can attend is worse than no charter, because it legitimises scheduling into hours where decisions will be made without a third of the team. The sprint mechanics that go with a short window are in our guide to running async sprints with a distributed developer team.

Step 5: Make escalation a name, not a channel

The escalation section of most charters says to post in an urgent channel. During the only event that matters, that resolves to nobody. A channel has no obligations and cannot be woken up.

Write a name, a contact method acceptable outside working hours, and the condition that justifies using it. Then write a deputy, because the first person will at some point be on a plane, and a one-name escalation path is a single point of failure you have documented rather than fixed. We also write the inverse, which people find more reassuring than the path itself: the short list of things that explicitly do not justify a waking-hours contact. Knowing what will not get you called at 2am is what makes people comfortable being on the list.

Our expert take

Step five is where I can tell, in about ninety seconds of reading, whether a company has had a real incident yet. Teams that have not been through one write escalation as a channel and a severity table. Teams that have been through one write a phone number and a deputy, because they remember the twenty minutes somebody spent working out who to wake. If you are hiring for a team that will carry production responsibility, this is also a useful interview topic: ask a candidate how escalation worked at their last job and you learn more about the operational maturity they are used to than any question about architecture will tell you.

Hiring into a distributed Dubai team

Send us your charter, or the fact that you do not have one, along with the role you are filling. We will tell you which parts of your working agreement a remote senior hire will struggle with in month one.

Get started

Step 6: Write down the bar for synchronous time

State the conditions that earn a meeting. Ours: a decision with real disagreement, a design with unresolved trade-offs, or a conversation with a person rather than about a task. Then state what does not qualify, and put status at the top of that list.

Writing the bar down is what converts a preference into something a junior engineer can invoke. Everyone in the industry claims to dislike unnecessary meetings and almost nobody feels able to decline one, because declining requires a reason and the reason sounds personal. A written bar makes the reason institutional: this does not meet the bar in the charter. I have watched a second-year engineer use that sentence on a director, politely, successfully, in a way that would have been unthinkable without the document.

Add one clause about what replaces the meeting you did not have, or the bar becomes a way of avoiding work. For us, anything that fails the bar becomes a written update with a named owner and a date, which is usually what the meeting would have produced anyway.

Step 7: Review against real incidents, not on a calendar

Once a quarter, collect the three worst communication failures that actually happened, and check each one against the charter. For every failure there are exactly three outcomes: the charter covered it and was ignored, which is an enforcement problem and not a drafting one; the charter was silent, which earns a new line; or the charter caused it, which happens more often than people expect and earns a deletion.

This review mechanism is why the document stays short. A calendar review asks what should we add, and the answer is always something. An incident review asks what actually broke, and most quarters the honest answer is nothing new. Our charter is shorter today than it was a year ago: three rules were retired after turning out to be one-off decisions dressed up as policy.

Keep the record of what you removed and why, in the decision log from step one. The question of why a rule is not in the charter comes up more often than you would think, usually from a new joiner who has seen it elsewhere.

The one-page charter, in order1. Decision recordDate, decision, reason, who to ask. Written by whoever decided, within one day.2. One job per channelAnd one sentence on what must never go there. The second half does the work.3. Response windowsAttached to channels, never to people. Removes out-of-hours guilt.4. Overlap windowStated honestly, and reserved for the three things that need everyone.5. EscalationA name and a deputy, plus the list of things that do not justify a call.6. Synchronous barWhat earns a meeting, what does not, and what replaces the one you skipped.7. Quarterly reviewAgainst the three worst real failures. Add a line, or delete one. Stay at one page.

The Three Mistakes I Made in the First Draft

The first was starting with channels, which I have already admitted to. The draft I wrote that evening was a routing table, and it did nothing for six weeks until I added the decision record and realised that was the only part anyone used.

The second was writing it as values. My first version had a line about respecting deep work: true, uncontroversial, unenforceable. Every rule needs an address and a time, meaning where the thing goes and by when. If a line cannot be violated in a way you could point at, delete it.

The third was writing it alone and publishing it finished. The team read it as policy and worked around it politely for a month. The version that stuck was drafted by one person, circulated with a deadline for objections, discussed once for the three items that drew real disagreement, then published with a name on it. Single ownership of the text, shared ownership of the outcome, and the discussion confined to the parts people actually cared about.

What This Changes About Hiring

A written charter does two things for a hiring process that are not obvious until you have one. It gives a candidate something concrete to react to, and their reaction is a signal. An engineer who reads a one-page working agreement and asks what happens when a decision in the log turns out to be wrong is telling you how they think. An engineer who skims it and says it looks great is telling you something too.

It also compresses onboarding. The first three weeks of a remote senior hire are mostly spent inferring the unwritten rules of a team, and inference is slow, error-prone and invisible to the manager. Handing over the rules on day one converts that into reading. The rest of that sequence is in our remote developer onboarding programme, and the adjacent written agreement for code sits in our engineering code review policy.

Our expert take

The reason I keep pushing the one-page limit is that a charter is not really a rulebook, it is a list of the decisions a team has made about how it works. A page holds roughly nine or ten such decisions, which is about as many as a group of people can actually hold in their heads and apply under pressure. Past that, the document stops being a shared agreement and becomes a reference nobody consults, which is indistinguishable from having no agreement except that it took longer to produce. When a team asks me to review a six-page charter, the useful work is almost always deletion.

When This Is the Wrong Thing to Spend a Week On

Three cases where I would not write a charter yet.

  1. A team of three or fewer, all in one timezone. The coordination cost a charter addresses does not exist at that size. Write the decision record rule from step one, which costs an afternoon and pays off the moment you hire a fourth person, and skip the rest until geography or headcount forces it.
  2. A team in the middle of a reorganisation. A working agreement written against a structure that is about to change documents a configuration that will not exist. Wait until the reporting lines and squad boundaries have settled. If you are mid-split, the sequencing question is covered in splitting an engineering team into squads.
  3. A team whose real problem is trust. A charter codifies how a group that broadly respects each other prefers to work. It does nothing about a team where two people do not believe each other, and shipping one into that situation gives both of them a document to cite in the argument. Fix the relationship first, write the rules second.

If what you are standardising is the pipeline rather than the conversation, the delivery practice side of the same question is in our guide to DevOps in the UAE.

Frequently Asked Questions

Is a communication charter not just a longer version of team norms nobody reads?
It becomes that if you write it as values rather than as rules with addresses. The difference between a charter that works and a document that gets ignored is specificity about location and timing. Respect each other focus time is a value and it changes nothing. Design discussions happen in pull request comments, decisions land in the decision log within one working day, and the overlap window is reserved for decisions with live disagreement is a rule, and a new joiner can follow it on their first morning. The test I apply before shipping a charter is whether someone could violate it accidentally and be shown exactly which line they missed. If no line can be pointed at, it is not a charter.
How long should the charter be?
One page, and that constraint does more work than anything written on the page. A one-page limit forces you to decide which rules actually matter, and it makes the document reviewable by a candidate during onboarding rather than filed for later. Every charter I have seen past three pages was a record of past arguments rather than a working agreement, and the sections added after an incident are the first ones people stop reading. When the quarterly review adds something, remove something. The charter should get shorter over its first year as rules that were really one-off decisions get retired.
Who should write it, the engineering manager or the team?
The manager drafts, the team amends, the manager owns the final text. Pure consensus drafting produces a document that avoids every contentious question, which is to say it avoids the only questions worth writing down. Pure top-down drafting produces a document the team treats as policy to be worked around. The sequence that works is a first draft written by one person in an afternoon, circulated with a deadline for objections, discussed once in the overlap window for the three items that drew real disagreement, then published with the author name on it. Shared ownership of the outcome, single ownership of the text.
Does this apply if the whole team sits in one Dubai office?
Partly, and the parts that apply are the ones most often skipped. A co-located team gets the overlap window and the response-time rules for free, because proximity solves them, so steps three and four matter much less. The decision record in step one matters more, not less: a co-located team makes decisions in conversations at a desk, which leaves no trace at all, and the first remote hire or the first new joiner six months later inherits a system whose reasoning is undocumented. If you are in one office today and plan to hire remotely at any point, write the decision record rule now while it is cheap. The rest can wait until geography forces it.

Building a distributed engineering team in the UAE

We screen developers for UAE employers who work across timezones, and we test for the thing a charter cannot teach: whether somebody writes down what they decided without being asked twice.

Get started