When to Deploy on a Distributed Team
Marco pushed the payments change at 6:10pm in Lisbon. A small thing, a currency-rounding fix he'd tested all afternoon, and it went out green. He closed his laptop and went to dinner. The deploy was fine for about four hours. Then the US evening traffic rolled in, a code path he hadn't thought about started double-charging one specific card type, and the first alert fired at 1am Lisbon time into a channel where the only person who understood the billing logic was asleep. The engineer on duty in Denver saw the pages, opened the diff, and spent two hours reverse-engineering a change she hadn't written while customers kept getting charged twice. Marco woke to forty Slack messages and a rollback he could have done himself in five minutes, if only he'd been awake.
Nothing about the code was the problem. The timing was. Marco shipped at the end of his day into the start of everyone else's night, and left a change nobody but him understood running unsupervised through the exact hours he was unreachable.
"Don't deploy on Friday" is the wrong rule
Every engineer has heard the advice: don't deploy on Friday afternoon. The reasoning is sound. Don't ship something risky right before the people who'd fix it vanish for the weekend. But the rule smuggles in an assumption that quietly falls apart on a distributed team, which is that there's a shared Friday, a shared afternoon, a shared moment when everyone is about to log off at once.
On a team spread across the planet, none of that exists. It is always someone's Friday afternoon and always someone's Monday morning. "End of day" points at a different hour for every person reading it. The real idea underneath the Friday rule still holds, but you have to restate it in a form that works when there is no shared clock: don't deploy when the people who can fix the fallout are about to be unreachable. For a team in one city, that's Friday at 4pm. For a team scattered across nine timezones, it's whenever you ship into your own night without first checking whose day you're shipping into.
Who's awake behind the deploy
Most changes that break don't break in the first ten minutes, while you're still watching the dashboard with your coffee. They break an hour later under real traffic, or when a nightly job fires, or when a region you forgot about wakes up and starts hammering the new feature. So the question that decides whether a deploy goes well isn't what time your clock says. It's who is awake and competent for the few hours after you ship, while the change is settling into production.
A distributed team has a real advantage here, the same one it has with on-call coverage. There is almost always someone awake. You rarely ship into a true dead zone where the whole company is asleep at once. What you do have to do is actually look. Before any deploy that isn't trivial, the check worth running is this: if this goes sideways in the next three hours, is there someone online who will both notice and be able to act? Not just someone holding the pager. Someone who understands this particular change well enough to roll it back or patch it without a two-hour dig through code they've never seen.
Marco's deploy failed that check, and he never ran it. He had plenty of daylight behind him in the Americas, bodies online and awake. Not one of them knew the billing code. Coverage is not a headcount of who's logged in. It's whether the knowledge the change depends on is awake.
Match the deploy to the daylight you have
The practical move is to stop shipping on your own convenience and start shipping into the window where the change is best supported. For most people that means deploying earlier in your working day instead of at the tail of it, so you're around for the aftermath rather than asleep through it.
The worst habit in distributed engineering is the end-of-day ship. You finish the work, you want it off your plate, you push it out the door and log off. That is the precise moment you should hold it overnight. You've just pulled the one person who understands the change best out of the hours it's most likely to misbehave. Shipping in your morning buys you a second thing too: a long runway of your own working day behind the deploy to catch and fix whatever it stirs up. Ship in your evening and the runway belongs to someone else, borrowed, and they didn't write the thing.
There's a better version of this for teams that genuinely cover the clock. If three people in three timezones understand a given system, you can deploy at almost any hour, because there's always informed coverage behind it. That's worth building toward, and it's the same investment that makes on-call humane: more than one person, in more than one part of the world, who can respond to each system that matters. Until you have it, your real deploy windows are narrower than the calendar suggests, and they're bounded by where the knowledge sleeps.
Write the deploy so a stranger can catch it
Even perfect timing fails if the awake person can't tell what you changed or how to undo it. A deploy on a distributed team should assume it'll be read by someone who wasn't in your head when you wrote it. That's the same discipline as writing anything down for people in other timezones, aimed at the riskiest minute of the week.
In practice, leave a trail a tired engineer at an unfamiliar hour can follow: what went out, what it touches, how to roll it back, and what to watch for over the next few hours. Feature-flag anything you're nervous about, so the fix is a toggle someone else can flip rather than a revert-and-redeploy they have to reason their way through at 3am. And keep the change small enough that when it breaks, the blast radius is obvious. A giant deploy that fails overnight for a stranger is a cruel puzzle. A small, flagged one is a thirty-second switch. The size of your pull request is also the size of the problem you're handing to whoever is awake when it goes wrong, which is the same reason small PRs clear review faster: you're shrinking what another human has to hold in their head at the worst possible moment to be holding anything.
The launch is a different animal
It's worth separating routine shipping from its louder cousin. A daily deploy and a coordinated product launch run on different timing logic. A launch is a single synchronized instant you've planned for weeks, with a named owner and a watch rotation standing by on purpose. Routine shipping is the background hum, dozens of small changes a week, and you can't convene a war room for each one.
This is about the hum, not the event. The launch gets its plan and its live coverage. The daily deploy just needs you to glance at a clock that shows other people's hours before you press the button, and to resist shipping into your own night because you want to be done.
Make it a team norm, not a personal habit
Individual discipline only reaches so far, because the person most tempted to ship-and-vanish is often the most junior, the one who hasn't yet been burned by the tail. So make it explicit. Agree as a team on when it's okay to deploy and when it isn't, written in terms of coverage rather than wall-clock time. Something like: don't ship a risky change unless someone who understands it will be online for the next few hours, and if that someone is only you and you're about to log off, it waits until your morning.
Put the rule where people see it, and treat a deploy that broke overnight with nobody awake to catch it as a process miss, not a personal failing. None of this is about slowing shipping down. A distributed team can ship faster than a single-office one precisely because the clock is covered somewhere at every hour. It's about aiming your deploys at the coverage you already have, instead of firing them into the dark and hoping the person who wakes up to the mess happens to know what you did. Marco's team added one line to their deploy checklist after that night: say who's awake behind this. The double-charge never happened again, and nobody shipped slower for it.
Related Reading
- How to Run On-Call Across Timezones — the coverage map this borrows from, pointed at the moment after you ship rather than the moment something pages
- Coordinating a Product Launch Across Timezones — the planned, synchronized go-live event that a routine deploy is deliberately not
- Write It Down on a Distributed Team — why the deploy needs a trail the awake stranger can actually follow
- Code Review Across Timezones — the case for small changes, here as a kindness to whoever's awake when one breaks
Let Timely Handle the Clock Math
Half of deciding when to ship is reading a clock that isn't yours. "I'm around until 6 if anyone needs me" means nothing when the person reading it is nine hours away and has to do the offset math before they know whether you'll still be online when their region wakes up. Timely reads each person's Slack timezone and quietly converts every time mentioned into the reader's own local clock, so a deploy window, a coverage promise, or a "back online at 14:00 my time" lands correctly wherever it's read. It won't decide when to deploy for you, but it makes the one question that matters, who's awake behind this, easy to answer at a glance.